nkululeko 0.59.1__py3-none-any.whl → 0.61.0__py3-none-any.whl

nkululeko/constants.py

@@ -1 +1 @@
-VERSION = '0.59.1'
+VERSION = '0.61.0'

nkululeko/experiment.py

@@ -2,13 +2,13 @@ import random
 import os
 import time
 import numpy as np
-from nkululeko.dataset import Dataset
-from nkululeko.dataset_csv import Dataset_CSV
-from nkululeko.dataset_ravdess import Ravdess
+from nkululeko.data.dataset import Dataset
+from nkululeko.data.dataset_csv import Dataset_CSV
+from nkululeko.data.dataset_ravdess import Ravdess
 from nkululeko.filter_data import filter_min_dur
 from nkululeko.runmanager import Runmanager
 from nkululeko.test_predictor import Test_predictor
-from nkululeko.feats_analyser import FeatureAnalyser
+from nkululeko.feat_extract.feats_analyser import FeatureAnalyser
 from nkululeko.util import Util
 from nkululeko.feature_extractor import FeatureExtractor
 from nkululeko.plots import Plots
@@ -148,32 +148,32 @@ class Experiment:
             self.df_train = self._import_csv(storage_train)
         else:
             self.df_train, self.df_test = pd.DataFrame(), pd.DataFrame()
-            strategy = self.util.config_val('DATA', 'strategy', 'traintest')
-            # some datasets against others in their entierty
-            if strategy == 'cross_data':
-                train_dbs = ast.literal_eval(glob_conf.config['DATA']['trains'])
-                test_dbs = ast.literal_eval(glob_conf.config['DATA']['tests'])
-                for dn in train_dbs:
-                    d = self.datasets[dn]
-                    d.prepare_labels()
-                    self.df_train = self.df_train.append(self.util.make_segmented_index(d.df))
-                    self.util.copy_flags(d, self.df_train)
-                for dn in test_dbs:
-                    d = self.datasets[dn]
-                    d.prepare_labels()
-                    self.df_test = self.df_test.append(self.util.make_segmented_index(d.df))
-                    self.util.copy_flags(d, self.df_test)
-            elif strategy == 'traintest':
+            # strategy = self.util.config_val('DATA', 'strategy', 'traintest')
+            # # some datasets against others in their entierty
+            # if strategy == 'cross_data':
+            #     train_dbs = ast.literal_eval(glob_conf.config['DATA']['trains'])
+            #     test_dbs = ast.literal_eval(glob_conf.config['DATA']['tests'])
+            #     for dn in train_dbs:
+            #         d = self.datasets[dn]
+            #         d.prepare_labels()
+            #         self.df_train = self.df_train.append(self.util.make_segmented_index(d.df))
+            #         self.util.copy_flags(d, self.df_train)
+            #     for dn in test_dbs:
+            #         d = self.datasets[dn]
+            #         d.prepare_labels()
+            #         self.df_test = self.df_test.append(self.util.make_segmented_index(d.df))
+            #         self.util.copy_flags(d, self.df_test)
+            # elif strategy == 'traintest':
                 # default: train vs. test combined from all datasets
-                for d in self.datasets.values():
-                    d.split()
-                    d.prepare_labels()
-                    self.df_train = pd.concat([self.df_train, d.df_train])
-                    self.util.copy_flags(d, self.df_train)
-                    self.df_test = pd.concat([self.df_test, d.df_test])
-                    self.util.copy_flags(d, self.df_test)
-            else:
-                self.util.error(f'unknown strategy: {strategy}')
+            for d in self.datasets.values():
+                d.split()
+                d.prepare_labels()
+                self.df_train = pd.concat([self.df_train, d.df_train])
+                self.util.copy_flags(d, self.df_train)
+                self.df_test = pd.concat([self.df_test, d.df_test])
+                self.util.copy_flags(d, self.df_test)
+            # else:
+            #     self.util.error(f'unknown strategy: {strategy}')
             # save the file lists to disk for later reuse
             store = self.util.get_path('store')
             storage_test = f'{store}testdf.csv'
@@ -313,7 +313,7 @@ class Experiment:
         """
         Augment the selected samples
         """
-        from nkululeko.augmenter import Augmenter
+        from nkululeko.augmenting.augmenter import Augmenter
         sample_selection = self.util.config_val('DATA', 'augment', 'train')
         if sample_selection=='all':
             df = pd.concat([self.df_train, self.df_test])
@@ -343,43 +343,43 @@ class Experiment:
         targets = self.util.config_val_list('PREDICT', 'targets', ['gender'])
         for target in targets:
             if target == 'gender':
-                from nkululeko.ap_gender import GenderPredictor
+                from nkululeko.autopredict.ap_gender import GenderPredictor
                 predictor = GenderPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'age':
-                from nkululeko.ap_age import AgePredictor
+                from nkululeko.autopredict.ap_age import AgePredictor
                 predictor = AgePredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'snr':
-                from nkululeko.ap_sdr import SNRPredictor
+                from nkululeko.autopredict.ap_sdr import SNRPredictor
                 predictor = SNRPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'mos':
-                from nkululeko.ap_mos import MOSPredictor
+                from nkululeko.autopredict.ap_mos import MOSPredictor
                 predictor = MOSPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'pesq':
-                from nkululeko.ap_pesq import PESQPredictor
+                from nkululeko.autopredict.ap_pesq import PESQPredictor
                 predictor = PESQPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'sdr':
-                from nkululeko.ap_sdr import SDRPredictor
+                from nkululeko.autopredict.ap_sdr import SDRPredictor
                 predictor = SDRPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'stoi':
-                from nkululeko.ap_stoi import STOIPredictor
+                from nkululeko.autopredict.ap_stoi import STOIPredictor
                 predictor = STOIPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'arousal':
-                from nkululeko.ap_arousal import ArousalPredictor
+                from nkululeko.autopredict.ap_arousal import ArousalPredictor
                 predictor = ArousalPredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'valence':
-                from nkululeko.ap_valence import ValencePredictor
+                from nkululeko.autopredict.ap_valence import ValencePredictor
                 predictor = ValencePredictor(df)
                 df = predictor.predict(sample_selection)
             elif target == 'dominance':
-                from nkululeko.ap_dominance import DominancePredictor
+                from nkululeko.autopredict.ap_dominance import DominancePredictor
                 predictor = DominancePredictor(df)
                 df = predictor.predict(sample_selection)
             else:
@@ -390,7 +390,7 @@ class Experiment:
         """
         Random-splice the selected samples
         """
-        from nkululeko.randomsplicer import Randomsplicer
+        from nkululeko.augmenting.randomsplicer import Randomsplicer
         sample_selection = self.util.config_val('DATA', 'random_splice', 'train')
         if sample_selection=='all':
             df = pd.concat([self.df_train, self.df_test])
@@ -552,5 +552,5 @@ class Experiment:
             f = open(filename, 'wb')
             pickle.dump(self.__dict__, f)
             f.close()
-        except (AttributeError, TypeError) as error: 
-            self.util.debug(f'Save experiment: Can\'t pickle local object: {error}')
+        except (AttributeError, TypeError, RuntimeError) as error: 
+            self.util.warn(f'Save experiment: Can\'t pickle local object: {error}')

nkululeko/feature_extractor.py

@@ -5,8 +5,9 @@ Helper class to encapsulate feature extraction methods
 
 """
 import pandas as pd
-from nkululeko.util import Util 
-from nkululeko.feats_opensmile import Opensmileset
+
+from nkululeko.feat_extract.feats_opensmile import Opensmileset
+from nkululeko.util import Util
 
 
 class FeatureExtractor:
@@ -16,80 +17,122 @@ class FeatureExtractor:
         data_df (pandas.DataFrame): dataframe with audiofile paths as index
         feats_types (array of strings): designations of acoustic feature extractors to be used
         data_name (string): names of databases that are extracted (for the caching)
-        feats_designation (string): the type of split (train/test), also is used for the cache name.    
+        feats_designation (string): the type of split (train/test), also is used for the cache name.
     Returns:
-        df (pandas.DataFrame): dataframe with same index as data_df and acoustic features in columns  
+        df (pandas.DataFrame): dataframe with same index as data_df and acoustic features in columns
     """
-    df = None # pandas dataframe to store the features (and indexed with the data from the sets)
-    data_df = None # dataframe to get audio paths
 
-# def __init__
+    # pandas dataframe to store the features (and indexed with the data from the sets)
+    df = None
+    data_df = None  # dataframe to get audio paths
+
+    # def __init__
     def __init__(self, data_df, feats_types, data_name, feats_designation):
         self.data_df = data_df
         self.data_name = data_name
         self.feats_types = feats_types
-        self.util = Util('feature_extractor')
+        self.util = Util("feature_extractor")
         self.feats_designation = feats_designation
-    
+
     def extract(self):
         # feats_types = self.util.config_val_list('FEATS', 'type', ['os'])
         self.featExtractor = None
-        self.feats= pd.DataFrame()
+        self.feats = pd.DataFrame()
         _scale = True
         for feats_type in self.feats_types:
-            store_name = f'{self.data_name}_{feats_type}'   
-            if feats_type=='os':
-                self.featExtractor = Opensmileset(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='trill':
-                from nkululeko.feats_trill import TRILLset
-                self.featExtractor = TRILLset(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='wav2vec':
-                from nkululeko.feats_wav2vec2 import Wav2vec2
-                self.featExtractor = Wav2vec2(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='audmodel':
-                from nkululeko.feats_audmodel import AudModelSet
-                self.featExtractor = AudModelSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='auddim':
-                from nkululeko.feats_audmodel_dim import AudModelDimSet
-                self.featExtractor = AudModelDimSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='agender':
-                from nkululeko.feats_agender import AudModelAgenderSet
-                self.featExtractor = AudModelAgenderSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='agender_agender':
-                from nkululeko.feats_agender_agender import AgenderAgenderSet
-                self.featExtractor = AgenderAgenderSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='snr':
-                from nkululeko.feats_snr import SNRSet
-                self.featExtractor = SNRSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='mos':
-                from nkululeko.feats_mos import MOSSet
-                self.featExtractor = MOSSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='squim':
-                from nkululeko.feats_squim import SQUIMSet
-                self.featExtractor = SQUIMSet(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='clap':
-                from nkululeko.feats_clap import Clap
-                self.featExtractor = Clap(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='praat':
-                from nkululeko.feats_praat import Praatset
-                self.featExtractor = Praatset(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='mld':
-                from nkululeko.feats_mld import MLD_set
-                self.featExtractor = MLD_set(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='import':
-                from nkululeko.feats_import import Importset
-                self.featExtractor = Importset(f'{store_name}_{self.feats_designation}', self.data_df)
+            store_name = f"{self.data_name}_{feats_type}"
+            if feats_type == "os":
+                self.featExtractor = Opensmileset(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "trill":
+                from nkululeko.feat_extract.feats_trill import TRILLset
+                self.featExtractor = TRILLset(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "wav2vec":
+                from nkululeko.feat_extract.feats_wav2vec2 import Wav2vec2
+                self.featExtractor = Wav2vec2(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type in ("hubert", "hubert_ft", "hubert_large", 
+                                "hubert_xlarge", "hubert_xlarge_ft"):
+                from nkululeko.feat_extract.feats_hubert import Hubert
+                self.featExtractor = Hubert(
+                    f"{store_name}_{self.feats_designation}", self.data_df,
+                    feats_type
+                )
+ 
+            elif feats_type == "audmodel":
+                from nkululeko.feat_extract.feats_audmodel import AudModelSet
+                self.featExtractor = AudModelSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "auddim":
+                from nkululeko.feat_extract.feats_audmodel_dim import \
+                    AudModelDimSet
+                self.featExtractor = AudModelDimSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "agender":
+                from nkululeko.feat_extract.feats_agender import \
+                    AudModelAgenderSet
+                self.featExtractor = AudModelAgenderSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "agender_agender":
+                from nkululeko.feat_extract.feats_agender_agender import \
+                    AgenderAgenderSet
+                self.featExtractor = AgenderAgenderSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "snr":
+                from nkululeko.feat_extract.feats_snr import SNRSet
+                self.featExtractor = SNRSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "mos":
+                from nkululeko.feat_extract.feats_mos import MOSSet
+                self.featExtractor = MOSSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "squim":
+                from nkululeko.feat_extract.feats_squim import SQUIMSet
+                self.featExtractor = SQUIMSet(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "clap":
+                from nkululeko.feat_extract.feats_clap import Clap
+                self.featExtractor = Clap(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "praat":
+                from nkululeko.feat_extract.feats_praat import Praatset
+                self.featExtractor = Praatset(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "mld":
+                from nkululeko.feat_extract.feats_mld import MLD_set
+                self.featExtractor = MLD_set(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type == "import":
+                from nkululeko.feat_extract.feats_import import Importset
+                self.featExtractor = Importset(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
             else:
-                self.util.error(f'unknown feats_type: {feats_type}')
+                self.util.error(f"unknown feats_type: {feats_type}")
 
             self.featExtractor.extract()
             self.featExtractor.filter()
             # remove samples that were not extracted by MLD
-            #self.df_test = self.df_test.loc[self.df_test.index.intersection(featExtractor_test.df.index)]
-            #self.df_train = self.df_train.loc[self.df_train.index.intersection(featExtractor_train.df.index)]
-            self.util.debug(f'{feats_type}: shape : {self.featExtractor.df.shape}')
-            self.feats = pd.concat([self.feats, self.featExtractor.df], axis = 1)
+            # self.df_test = self.df_test.loc[self.df_test.index.intersection(featExtractor_test.df.index)]
+            # self.df_train = self.df_train.loc[self.df_train.index.intersection(featExtractor_train.df.index)]
+            self.util.debug(
+                f"{feats_type}: shape : {self.featExtractor.df.shape}")
+            self.feats = pd.concat([self.feats, self.featExtractor.df], axis=1)
         return self.feats
 
     def extract_sample(self, signal, sr):
-        return self.featExtractor.extract_sample(signal, sr)
+        return self.featExtractor.extract_sample(signal, sr)

nkululeko/modelrunner.py

@@ -59,44 +59,44 @@ class Modelrunner:
 
     def _select_model(self, model_type):
         if model_type=='svm':
-            from nkululeko.model_svm import SVM_model
+            from nkululeko.models.model_svm import SVM_model
             self.model = SVM_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='svr':
-            from nkululeko.model_svr import SVR_model
+            from nkululeko.models.model_svr import SVR_model
             self.model = SVR_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='xgb':
-            from nkululeko.model_xgb import XGB_model
+            from nkululeko.models.model_xgb import XGB_model
             self.model = XGB_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='xgr':
-            from nkululeko.model_xgr import XGR_model
+            from nkululeko.models.model_xgr import XGR_model
             self.model = XGR_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='bayes':
-            from nkululeko.model_bayes import Bayes_model
+            from nkululeko.models.model_bayes import Bayes_model
             self.model = Bayes_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='gmm':
-            from nkululeko.model_gmm import GMM_model
+            from nkululeko.models.model_gmm import GMM_model
             self.model = GMM_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='knn':
-            from nkululeko.model_knn import KNN_model
+            from nkululeko.models.model_knn import KNN_model
             self.model = KNN_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='knn_reg':
-            from nkululeko.model_knn_reg import KNN_reg_model
+            from nkululeko.models.model_knn_reg import KNN_reg_model
             self.model = KNN_reg_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='tree':
-            from nkululeko.model_tree import Tree_model
+            from nkululeko.models.model_tree import Tree_model
             self.model = Tree_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='tree_reg':
-            from nkululeko.model_tree_reg import Tree_reg_model
+            from nkululeko.models.model_tree_reg import Tree_reg_model
             self.model = Tree_reg_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='cnn':
-            from nkululeko.model_cnn import CNN_model
-            from nkululeko.model_cnn import CNN_model
+            from nkululeko.models.model_cnn import CNN_model
+            from nkululeko.models.model_cnn import CNN_model
             self.model = CNN_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='mlp':
-            from nkululeko.model_mlp import MLP_model
+            from nkululeko.models.model_mlp import MLP_model
             self.model = MLP_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         elif model_type=='mlp_reg':
-            from nkululeko.model_mlp_regression import MLP_Reg_model
+            from nkululeko.models.model_mlp_regression import MLP_Reg_model
             self.model = MLP_Reg_model(self.df_train, self.df_test, self.feats_train, self.feats_test)
         else:
             self.util.error(f'unknown model type: \'{model_type}\'')

nkululeko/plots.py

@@ -95,6 +95,17 @@ class Plots():
             else:
                 self.util.error(f'plot value counts: the plot distribution descriptor for {att} has more than 2 values')
 
+    def plot_durations(self, df, filename, sample_selection):
+        fig_dir = self.util.get_path('fig_dir')+'../' # one up because of the runs 
+        ax = sns.histplot(df, x='duration', hue='class_label', kde=True)
+        ax.set_title(f'{sample_selection} {df.shape[0]}')
+        ax.set_xlabel(f'duration')
+        ax.set_ylabel(f'number of samples')
+        fig = ax.figure
+        plt.tight_layout()
+        plt.savefig(f'{fig_dir}{filename}_{sample_selection}.{self.format}')
+        plt.close(fig)
+        fig.clear()   
 
     def describe_df(self, name, df, target, filename):
         """Make a stacked barplot of samples and speakers per sex and target values. speaker, gender and target columns must be present"""

nkululeko/segment.py

@@ -7,25 +7,8 @@ from nkululeko.util import Util
 from  nkululeko.constants import VERSION
 import argparse
 import os
-import torch
-import audformat
-from audformat.utils import to_filewise_index
-from audformat import segmented_index
 import pandas as pd 
 
-# initialize the VAD model
-SAMPLING_RATE = 16000
-torch.set_num_threads(1)
-vad_model, vad_utils = torch.hub.load(repo_or_dir='snakers4/silero-vad',
-                    model='silero_vad',
-                    force_reload=False,
-                    onnx=False)
-(get_speech_timestamps,
-save_audio,
-read_audio,
-VADIterator,
-collect_chunks) = vad_utils
-
 def main(src_dir):
     parser = argparse.ArgumentParser(description='Call the nkululeko framework.')
     parser.add_argument('--config', default='exp.ini', help='The base configuration')
@@ -60,7 +43,7 @@ def main(src_dir):
     util.debug(f'train shape : {expr.df_train.shape}, test shape:{expr.df_test.shape}')
 
     # segment
-    segment_target = util.config_val('DATA', 'segment_target', '_seg')
+    segment_target = util.config_val('SEGMENT', 'target', '_seg')
     # this if a specific dataset is to be segmented
     # segment_db = util.config_val('DATA', 'segment', False)
     # if segment_db:
@@ -72,7 +55,8 @@ def main(src_dir):
     #             name = f'{dataset}{segment_target}'
     #             df_seg.to_csv(f'{expr.data_dir}/{name}.csv')
 
-    sample_selection = util.config_val('DATA', 'segment', 'all')
+    segmenter = util.config_val('SEGMENT', 'method', 'silero')
+    sample_selection = util.config_val('SEGMENT', 'sample_selection', 'all')
     if sample_selection=='all':
         df = pd.concat([expr.df_train, expr.df_test])
     elif sample_selection=='train':
@@ -81,26 +65,38 @@ def main(src_dir):
         df = expr.df_test
     else:
         util.error(f'unknown segmentation selection specifier {sample_selection}, should be [all | train | test]')
+    # if "duration" not in df.columns:
+    #     df = df.drop(columns=['duration'], inplace=True)
+    util.debug(f'segmenting {sample_selection}: {df.shape[0]} samples with {segmenter}') 
+    if segmenter=='silero':
+        from nkululeko.segmenting.seg_silero import Silero_segmenter
+        segmenter = Silero_segmenter()
+        df_seg = segmenter.segment_dataframe(df)
+
+    else:
+        util.error(f'unkown segmenter: {segmenter}')
 
-    if "duration" not in df.columns:
-        df = df.drop(columns=['duration'], inplace=True)
-    util.debug(f'segmenting train and test set: {df.shape[0]} samples') 
-    df_seg = segment_dataframe(df) 
     def calc_dur(x):
+        from datetime import datetime
         starts = x[1]
         ends = x[2]
         return (ends - starts).total_seconds()
     df_seg['duration'] = df_seg.index.to_series().map(lambda x:calc_dur(x)) 
+    if "duration" not in df.columns:
+        df['duration'] = df.index.to_series().map(lambda x:calc_dur(x)) 
+    num_before = df.shape[0]
+    num_after = df_seg.shape[0]
     dataname = '_'.join(expr.datasets.keys())
     name = f'{dataname}{segment_target}'
     df_seg.to_csv(f'{expr.data_dir}/{name}.csv')
+    from nkululeko.plots import Plots
+    plots = Plots()
+    plots.plot_durations(df, 'original_durations', sample_selection)
+    plots.plot_durations(df_seg, 'segmented_durations', sample_selection)
     print('')
-    util.debug(f'saved {name}.csv to {expr.data_dir}, {df_seg.shape[0]} samples')
+    util.debug(f'saved {name}.csv to {expr.data_dir}, {num_after} samples (was {num_before})')
     print('DONE')
 
-
-
-
 def get_segmentation(file):
 #    print(f'segmenting {file[0]}')
     print('.', end='')

nkululeko/test_predictor.py

@@ -5,7 +5,7 @@
 import nkululeko.glob_conf as glob_conf
 from nkululeko.util import Util
 import pandas as pd
-from nkululeko.dataset import Dataset
+from nkululeko.data.dataset import Dataset
 from nkululeko.feature_extractor import FeatureExtractor
 from nkululeko.scaler import Scaler
 import numpy as np

{nkululeko-0.59.1.dist-info → nkululeko-0.61.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.59.1
+Version: 0.61.0
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -253,6 +253,18 @@ Nkululeko can be used under the [MIT license](https://choosealicense.com/license
 Changelog
 =========
 
+Version 0.61.0
+--------------
+* added HUBERT embeddings
+  
+Version 0.60.0
+--------------
+* some bugfixes
+* new package structure
+* fixed wav2vec2 bugs
+* removed "cross_data" strategy 
+
+
 Version 0.59.1
 --------------
 * bugfix, after fresh install, it seems some libraries have changed

nkululeko-0.61.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
+nkululeko/augment.py,sha256=ebv5QebGD8wLzXInvusjn4kFlET6-yXkYoF132BrubQ,1750
+nkululeko/balancer.py,sha256=64ftZN68sMDfkvuovCDHpAHmSJgCO6Kdk9bwmpSisec,12
+nkululeko/cacheddataset.py,sha256=bSJ_SDg7TxL89YL_pJXp-sFvdUXJtHuBTd5KSTE4AkQ,955
+nkululeko/constants.py,sha256=xSkfM3CWCYGD40D6GhHHCrxrw0JNK-372YdiRKMknWs,18
+nkululeko/demo.py,sha256=nGP3fUDXuW1ZF12AzMpzRWXct0rdqYRJVNgA9B_QWwA,1821
+nkululeko/demo_predictor.py,sha256=VVxE2lf5lTkAP5qElG5U2bK6SdDzQ2Jmf0Vn_yHpSro,2302
+nkululeko/experiment.py,sha256=9qStgy31svY4bBVZOkuJ0JFjEQ1sIT2ibIdJ6IVlfTI,25063
+nkululeko/explore.py,sha256=aemOk5XYw7axQEJQfdABEUxN3img0NYSb8l6W-nDzZY,2090
+nkululeko/feature_extractor.py,sha256=2LqPIiDAoaBRhjcKik2hjBEBVBsLLxx8blQvTD43TRg,6324
+nkululeko/file_checker.py,sha256=Nw05SIp7Ez1U9ZeFhNGz0XivwKr43hHg1WsfzKsrFPQ,3510
+nkululeko/filter_data.py,sha256=g7giEShbA-dr2ekVycW5WurFG-UaopJvDZWylKNZtpM,6717
+nkululeko/glob_conf.py,sha256=2Tl0NZQeVeydDO8T2tuJC2lCv99wvaTVRX9Dy1Mq_L4,237
+nkululeko/modelrunner.py,sha256=zVDi2-UyjtmU0_Ltf4lnPcECVtukuDVuZaj4pydqOBY,5478
+nkululeko/nkululeko.py,sha256=O2Zw7u-Mb7VP9MPxAlhdTkXV2lW2kETIuSJp7mfj_Tc,1671
+nkululeko/plots.py,sha256=hoOFLbWXpV5jGDWHEpy345_4vpaGKGMAv2JwvpNUxkw,11454
+nkululeko/predict.py,sha256=3ei4wn2by0p9Vkv7cllMcszmEjSM2vX0T6x_5rlgT28,1851
+nkululeko/reporter.py,sha256=359aeQWt0ZGLseaJnOfafYG8BrwumiM2Q58DWiaoyWQ,10177
+nkululeko/result.py,sha256=Ey5FPsAyfnQVtzO_J6_4hkOAZ191YWmF_vXxlgNjCdc,406
+nkululeko/runmanager.py,sha256=ll04dEu5Y1nOi8QOtmSiw3oxzcXeASdQsg0t-vxCny8,6765
+nkululeko/scaler.py,sha256=6NQHbSQZO9HIfhYNlliuDRywjaEH_FVKHRskTJ2xr90,3021
+nkululeko/segment.py,sha256=GGyovnZ75Sqd8TgBH5fi3fjRkVw_ygqBQD46Yn6GVQ4,4660
+nkululeko/syllable_nuclei.py,sha256=vK9dj5deqRnyEmlZmhFtKPzqKVGNCgTnWaG8UDITKNg,9913
+nkululeko/test.py,sha256=BbHGliDChAXqMe2oA579dJpyZSlPGAm5997lX_POboQ,1372
+nkululeko/test_predictor.py,sha256=QwdAVPHNew9w5PD_sPFhhWVDTYRAbUE6fkAp58X8Hjg,2410
+nkululeko/util.py,sha256=gZrNTF4C7hKkEMCC_hoNkEAhAViWzWebP8LsHRew7s4,9731
+nkululeko-0.61.0.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.61.0.dist-info/METADATA,sha256=LXJjW9KpGkPum60eGuYW__gl5QKXVRhnm6RySrKo2b8,21680
+nkululeko-0.61.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+nkululeko-0.61.0.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.61.0.dist-info/RECORD,,

{nkululeko-0.59.1.dist-info → nkululeko-0.61.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nkululeko/ap_age.py

@@ -1,31 +0,0 @@
-""""
-A predictor for age.
-Currently based on audEERING's agender model.
-"""
-from nkululeko.util import Util
-from nkululeko.feature_extractor import FeatureExtractor
-import ast
-import nkululeko.glob_conf as glob_conf
-class AgePredictor:
-    """
-    AgePredictor
-    predicting age with the audEERING agender model
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('agePredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'predicting age for {split_selection} samples')
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['agender_agender'], feats_name, split_selection)
-        agender_df = self.feature_extractor.extract()
-        pred_age = agender_df.age * 100
-#        pred_gender = agender_df.drop('age', axis=1).idxmax(axis=1)
-        return_df = self.df.copy()
-#        return_df['gender_pred'] = pred_gender
-        return_df['age_pred'] = pred_age.astype('int')
-        return return_df
-