nkululeko 0.60.0__py3-none-any.whl → 0.62.0__py3-none-any.whl

nkululeko/constants.py

@@ -1 +1 @@
-VERSION = '0.60.0'
+VERSION = '0.62.0'

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.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':
+            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':
+                self.featExtractor = TRILLset(
+                    f"{store_name}_{self.feats_designation}", self.data_df
+                )
+            elif feats_type.startswith("wav2vec2"):
                 from nkululeko.feat_extract.feats_wav2vec2 import Wav2vec2
-                self.featExtractor = Wav2vec2(f'{store_name}_{self.feats_designation}', self.data_df)
-            elif feats_type=='audmodel':
+                self.featExtractor = Wav2vec2(
+                    f"{store_name}_{self.feats_designation}", self.data_df,
+                    feats_type
+                )
+            elif feats_type.startswith("hubert"):
+                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':
+                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':
+                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':
+                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':
+                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':
+                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':
+                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':
+                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)
+                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/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/resample.py

@@ -0,0 +1,63 @@
+# resample.py
+# change the sampling rate for train and test splits
+
+from nkululeko.experiment import Experiment
+import configparser
+from nkululeko.util import Util
+from  nkululeko.constants import VERSION
+import argparse
+import os
+import pandas as pd
+from nkululeko.augmenting .resampler import Resampler
+
+def main(src_dir):
+    parser = argparse.ArgumentParser(description='Call the nkululeko framework.')
+    parser.add_argument('--config', default='exp.ini', help='The base configuration')
+    args = parser.parse_args()
+    if args.config is not None:
+        config_file = args.config    
+    else:
+        config_file = f'{src_dir}/exp.ini'
+
+    # test if the configuration file exists
+    if not os.path.isfile(config_file):
+        print(f'ERROR: no such file: {config_file}')
+        exit()
+        
+    # load one configuration per experiment
+    config = configparser.ConfigParser()
+    config.read(config_file)
+    # create a new experiment
+    expr = Experiment(config)
+    util = Util('resample')
+    util.debug(f'running {expr.name} from config {config_file}, nkululeko version {VERSION}')
+
+    if util.config_val('EXP', 'no_warnings', False):
+        import warnings
+        warnings.filterwarnings("ignore")
+
+    # load the data
+    expr.load_datasets()
+
+    # 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}')
+
+    sample_selection = util.config_val('RESAMPLE', 'sample_selection', 'all')
+    if sample_selection=='all':
+        df = pd.concat([expr.df_train, expr.df_test])
+    elif sample_selection=='train':
+        df = expr.df_train
+    elif sample_selection=='test':
+        df = expr.df_test
+    else:
+        util.error(f'unknown selection specifier {sample_selection}, should be [all | train | test]')
+    util.debug(f'resampling {sample_selection}: {df.shape[0]} samples') 
+    rs = Resampler(df)
+    rs.resample()
+    print('DONE')
+
+
+if __name__ == "__main__":
+    cwd = os.path.dirname(os.path.abspath(__file__))
+    main(cwd) # use this if you want to state the config file path on command line

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,19 +43,10 @@ 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')
-    # this if a specific dataset is to be segmented
-    # segment_db = util.config_val('DATA', 'segment', False)
-    # if segment_db:
-    #     for dataset in expr.datasets.keys:
-    #         if segment_db == dataset:
-    #             df = expr.datasets[dataset].df
-    #             util.debug(f'segmenting {dataset}') 
-    #             df_seg = segment_dataframe(df) 
-    #             name = f'{dataset}{segment_target}'
-    #             df_seg.to_csv(f'{expr.data_dir}/{name}.csv')
+    segment_target = util.config_val('SEGMENT', 'target', '_seg')
 
-    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 +55,43 @@ def main(src_dir):
         df = expr.df_test
     else:
         util.error(f'unknown segmentation selection specifier {sample_selection}, should be [all | train | test]')
+    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]
+    # plot distributions
+    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('')
+    # remove encoded labels
+    target = util.config_val('DATA', 'target', 'emotion')
+    if 'class_label' in df_seg.columns:
+        df_seg = df_seg.drop(columns=[target])
+        df_seg = df_seg.rename(columns={'class_label':target})
+    # save file
     dataname = '_'.join(expr.datasets.keys())
     name = f'{dataname}{segment_target}'
     df_seg.to_csv(f'{expr.data_dir}/{name}.csv')
-    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/util.py

@@ -2,7 +2,6 @@
 import audeer
 import ast 
 import sys
-import nkululeko.glob_conf as glob_conf
 import numpy as np
 import os.path
 import configparser
@@ -11,16 +10,20 @@ import pandas as pd
 
 class Util:
 
+    # a list of words that need not to be warned upon if default values are used
     stopvals = [False, 'False', 'classification', 'png']
 
-    def __init__(self, caller=None):
-        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
-            if not os.path.isfile(self.got_data_roots):
-                self.error(f'no such file: {self.got_data_roots}')
-            self.data_roots = configparser.ConfigParser()
-            self.data_roots.read(self.got_data_roots)
+    def __init__(self, caller=None, has_config=True):
+        if has_config:
+            import nkululeko.glob_conf as glob_conf
+            self.config = glob_conf.config
+            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
+                if not os.path.isfile(self.got_data_roots):
+                    self.error(f'no such file: {self.got_data_roots}')
+                self.data_roots = configparser.ConfigParser()
+                self.data_roots.read(self.got_data_roots)
         if caller is not None:
             self.caller = caller
         else:  
@@ -30,10 +33,10 @@ class Util:
         """
         This method allows the user to get the directory path for the given argument.
         """
-        root = glob_conf.config['EXP']['root']
-        name = glob_conf.config['EXP']['name']
+        root = self.config['EXP']['root']
+        name = self.config['EXP']['name']
         try:
-            entryn = glob_conf.config['EXP'][entry]
+            entryn = self.config['EXP'][entry]
         except KeyError:
             # some default values
             if entry == 'fig_dir':
@@ -61,7 +64,7 @@ class Util:
         If the value is present in the experiment configuration it will be used, else 
         we look in a global file specified by the root_folders value.
         """
-        configuration = glob_conf.config
+        configuration = self.config
         try:
             if len(key)>0:
                 return configuration['DATA'][dataset+'.'+key]
@@ -95,8 +98,8 @@ class Util:
         """
             Get the experiment directory
         """
-        root = glob_conf.config['EXP']['root']
-        name = glob_conf.config['EXP']['name']
+        root = self.config['EXP']['root']
+        name = self.config['EXP']['name']
         dir_name = f'{root}{name}'
         audeer.mkdir(dir_name)
         return dir_name
@@ -124,19 +127,19 @@ class Util:
         """
             Get a string as name from all databases that are useed
         """
-        return '_'.join(ast.literal_eval(glob_conf.config['DATA']['databases']))
+        return '_'.join(ast.literal_eval(self.config['DATA']['databases']))
     
     def get_exp_name(self, only_train = False, only_data = False):
         trains_val = self.config_val('DATA', 'trains', False)
         if only_train and trains_val:
             # try to get only the train tables
-            ds = '_'.join(ast.literal_eval(glob_conf.config['DATA']['trains']))
+            ds = '_'.join(ast.literal_eval(self.config['DATA']['trains']))
         else:
-            ds = '_'.join(ast.literal_eval(glob_conf.config['DATA']['databases']))
+            ds = '_'.join(ast.literal_eval(self.config['DATA']['databases']))
         mt = ''
         if not only_data:
-            mt = f'_{glob_conf.config["MODEL"]["type"]}'
-        ft = '_'.join(ast.literal_eval(glob_conf.config['FEATS']['type']))
+            mt = f'_{self.config["MODEL"]["type"]}'
+        ft = '_'.join(ast.literal_eval(self.config['FEATS']['type']))
         ft += '_'
         set = self.config_val('FEATS', 'set', False)
         set_string = ''
@@ -159,7 +162,7 @@ class Util:
 
     def get_plot_name(self):
         try:
-            plot_name = glob_conf.config['PLOT']['name']
+            plot_name = self.config['PLOT']['name']
         except KeyError:
             plot_name = self.get_exp_name()
         return plot_name
@@ -183,10 +186,10 @@ class Util:
     def set_config_val(self, section, key, value):
         try:
             # does the section already exists?
-            glob_conf.config[section][key] = str(value)
+            self.config[section][key] = str(value)
         except KeyError:
-            glob_conf.config.add_section(section)
-            glob_conf.config[section][key] = str(value)
+            self.config.add_section(section)
+            self.config[section][key] = str(value)
     
     def check_df(self, i, df):
         """Check a dataframe"""
@@ -195,7 +198,7 @@ class Util:
         )
     def config_val(self, section, key, default):
         try:
-            return glob_conf.config[section][key]
+            return self.config[section][key]
         except KeyError:
             if not default in self.stopvals:
                 self.debug(f'value for {key} not found, using default: {default}')
@@ -203,7 +206,7 @@ class Util:
             
     def config_val_list(self, section, key, default):
         try:
-            return ast.literal_eval(glob_conf.config[section][key])
+            return ast.literal_eval(self.config[section][key])
         except KeyError:
             if not default in self.stopvals:
                 self.debug(f'value for {key} not found, using default: {default}')
@@ -213,11 +216,11 @@ class Util:
         # try:
         #     labels = glob_conf.label_encoder.classes_
         # except AttributeError:
-        labels = ast.literal_eval(glob_conf.config['DATA']['labels'])
+        labels = ast.literal_eval(self.config['DATA']['labels'])
         return labels
 
     def continuous_to_categorical(self, array):
-        bins = ast.literal_eval(glob_conf.config['DATA']['bins'])
+        bins = ast.literal_eval(self.config['DATA']['bins'])
         result =  np.digitize(array, bins)-1
         return result
 

{nkululeko-0.60.0.dist-info → nkululeko-0.62.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.60.0
+Version: 0.62.0
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -253,6 +253,17 @@ Nkululeko can be used under the [MIT license](https://choosealicense.com/license
 Changelog
 =========
 
+Version 0.62.0
+--------------
+* fixed segment silero bug
+* added all Wav2vec2 models
+* added resampler module
+* added error on file for embeddings
+
+Version 0.61.0
+--------------
+* added HUBERT embeddings
+  
 Version 0.60.0
 --------------
 * some bugfixes

{nkululeko-0.60.0.dist-info → nkululeko-0.62.0.dist-info}/RECORD

@@ -2,30 +2,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=bmZ-IYOBLr7300ZA6Lk76zK1bBaZbY-EMByZnpKFkiI,18
+nkululeko/constants.py,sha256=7u8AMX9auXDDDSpQnfb8--c2xIvy8IAsVaxENC-wi0k,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=ZNNgf5u_daxoJ7Ys4jtT4tYD2PNNyV950Pa_R1c2gPM,5297
+nkululeko/feature_extractor.py,sha256=h2kMJR6fElshCUXw_A6fg3gNbKRMXrZR4SGhaaQI4wk,6274
 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=rr4Fa0kckRNw5-mz9clikiB5ul8XJ9U4_1OebCUiNWw,10924
+nkululeko/plots.py,sha256=hoOFLbWXpV5jGDWHEpy345_4vpaGKGMAv2JwvpNUxkw,11454
 nkululeko/predict.py,sha256=3ei4wn2by0p9Vkv7cllMcszmEjSM2vX0T6x_5rlgT28,1851
 nkululeko/reporter.py,sha256=359aeQWt0ZGLseaJnOfafYG8BrwumiM2Q58DWiaoyWQ,10177
+nkululeko/resample.py,sha256=392zQEpRaWGwBvRBMXY9j2WtTTEaELk8HRPQ6ajzJSQ,2121
 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=xmkZrA3iEsro7vaBwWdey_pIleS1tYyjTFe-EfMUQHQ,4399
+nkululeko/segment.py,sha256=YcrSQ_iP80inPZbXN4jFpKbMmGxI_Xcev5IfK0GSdJ0,4349
 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.60.0.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.60.0.dist-info/METADATA,sha256=p1kHUf0egmZQHlH4RbGg2MdbYf9GmMvuW37LHMNWmvY,21621
-nkululeko-0.60.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-nkululeko-0.60.0.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.60.0.dist-info/RECORD,,
+nkululeko/util.py,sha256=VE8HbcdUkfHbo1xQNVznyemoE-OVeWgDwsjbZpEBqUA,9840
+nkululeko-0.62.0.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.62.0.dist-info/METADATA,sha256=lQogxZd1eFD1PEKzwujzUSHQU3sju2IY3v7QQM0ddLE,21828
+nkululeko-0.62.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+nkululeko-0.62.0.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.62.0.dist-info/RECORD,,