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

nkululeko/feats_agender_agender.py

@@ -1,65 +0,0 @@
-# feats_audmodel_dim.py
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import audeer
-import nkululeko.glob_conf as glob_conf
-import audonnx
-import numpy as np
-import audinterface
-
-class AgenderAgenderSet(Featureset):
-    """
-        Age and gender predictions from the wav2vec2. based model finetuned on agender, described in the paper
-        "Speech-based Age and Gender Prediction with Transformers"
-        https://arxiv.org/abs/2306.16962
-    """
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)
-        model_url = 'https://zenodo.org/record/7761387/files/w2v2-L-robust-6-age-gender.25c844af-1.1.1.zip'
-        model_root = self.util.config_val('FEATS', 'agender.model', './audmodel_agender/')
-        if not os.path.isdir(model_root):
-            cache_root = audeer.mkdir('cache')
-            model_root = audeer.mkdir(model_root)
-            archive_path = audeer.download_url(model_url, cache_root, verbose=True)
-            audeer.extract_archive(archive_path, model_root)
-        device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.model = audonnx.load(model_root, device=device)
-
-
-    def extract(self):
-        """Extract the features based on the initialized dataset or re-open them when found on disk."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        extract = eval(self.util.config_val('FEATS', 'needs_feature_extraction', 'False'))
-        no_reuse = eval(self.util.config_val('FEATS', 'no_reuse', 'False'))
-        sampling_rate = 16000
-        if no_reuse or extract or not os.path.isfile(storage):
-            self.util.debug('extracting agender model age and gender, this might take a while...')
-            outputs = ['logits_age', 'logits_gender']
-            logits = audinterface.Feature(
-                self.model.labels(outputs),
-                process_func=self.model,
-                process_func_args={
-                    'outputs': outputs,
-                    'concat': True,
-                },
-                sampling_rate=sampling_rate,
-                resample=True,    
-                verbose=True,
-            )
-            self.df = logits.process_index(self.data_df.index)
-            self.util.write_store(self.df, storage, store_format)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'False'
-            except KeyError:
-                pass
-        else:
-            self.util.debug('reusing extracted audmodel features.')
-            self.df = self.util.get_store(storage, store_format)
-
-
-    def extract_sample(self, signal, sr):
-        result = self.model(signal, sr)
-        return np.asarray(result['hidden_states'].flatten())

nkululeko/feats_analyser.py

@@ -1,87 +0,0 @@
-# feats_analyser.py
-import pandas as pd
-from nkululeko.util import Util 
-from nkululeko.plots import Plots
-from sklearn.linear_model import LogisticRegression
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.linear_model import LinearRegression
-from sklearn.tree import DecisionTreeRegressor
-import matplotlib.pyplot as plt
-
-class FeatureAnalyser:
- 
-
-    def __init__(self, label, df_labels, df_features):
-        self.util = Util('feats_analyser')
-        target = self.util.config_val('DATA', 'target', 'emotion')    
-        self.y = df_labels[target]
-        self.df_labels = df_labels
-        self.X = df_features
-        self.label = label
-
-
-    def analyse(self):
-        model_s = self.util.config_val('EXPL', 'model', 'log_reg')
-        max_feat_num = int(self.util.config_val('EXPL', 'max_feats', '10'))
-        importance = None
-        self.util.debug('analysing features...')
-        if self.util.exp_is_classification():
-            if model_s == 'log_reg':
-                model = LogisticRegression()
-                model.fit(self.X, self.y)
-                importance = model.coef_[0]
-            elif model_s == 'tree':
-                model = DecisionTreeClassifier()
-                model.fit(self.X, self.y)
-                importance = model.feature_importances_
-                plot_tree = eval(self.util.config_val('EXPL', 'plot_tree', 'False'))
-                if plot_tree:
-                    plots = Plots()
-                    plots.plot_tree(model, self.X)
-            else:
-                self.util.error(f'invalid analysis method: {model}')
-        else: # regression experiment
-            if model_s == 'lin_reg':
-                model = LinearRegression()
-                model.fit(self.X, self.y)
-                importance = model.coef_
-            elif model_s == 'tree':
-                model = DecisionTreeRegressor()
-                model.fit(self.X, self.y)
-                importance = model.feature_importances_
-            else:
-                self.util.error(f'invalid analysis method: {model_s}')
-
-        df_imp = pd.DataFrame({'feats':self.X.columns, 'importance':importance})
-        df_imp = df_imp.sort_values(by='importance', ascending=False).iloc[:max_feat_num]
-        ax = df_imp.plot(x='feats', y='importance', kind='bar')
-        ax.set(title=f'{self.label} samples')
-        plt.tight_layout()
-        fig_dir = self.util.get_path('fig_dir')+'../' # one up because of the runs 
-        exp_name = self.util.get_exp_name(only_data=True)
-        format = self.util.config_val('PLOT', 'format', 'png')
-        filename = f'{fig_dir}{exp_name}EXPL_{model_s}.{format}'
-        plt.savefig(filename)
-        fig = ax.figure
-        fig.clear()
-        plt.close(fig)
-        # result file
-        res_dir = self.util.get_path('res_dir')
-        file_name = f'{res_dir}{self.util.get_exp_name(only_data=True)}EXPL_{model_s}.txt'
-        with open(file_name, "w") as text_file:
-            text_file.write(f'features in order of decreasing importance according to model {model_s}:\n'+
-            f'{str(df_imp.feats.values)}\n')
-
-        df_imp.to_csv(file_name, mode='a')
-
-                # check if feature distributions should be plotted
-        plot_feats = self.util.config_val('EXPL', 'feature_distributions', False)
-        if plot_feats: 
-            sample_selection = self.util.config_val('EXPL', 'sample_selection', 'all')
-            if self.util.exp_is_classification():
-                for feature in df_imp.feats:
-                    # plot_feature(self, title, feature, label, df_labels, df_features):
-                    _plots = Plots()
-                    _plots.plot_feature(sample_selection, feature, 'class_label', self.df_labels, self.X)
-            else:
-                self.util.debug('can\'t plot feature distributions if not classification')

nkululeko/feats_audmodel.py

@@ -1,63 +0,0 @@
-# feats_audmodel.py
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import audeer
-import nkululeko.glob_conf as glob_conf
-import audonnx
-import numpy as np
-import audinterface
-
-class AudModelSet(Featureset):
-    """
-        Embeddings from the wav2vec2. based model finetuned on MSPPodcast emotions, described in the paper
-        "Dawn of the transformer era in speech emotion recognition: closing the valence gap"
-        https://arxiv.org/abs/2203.07378
-    """
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)
-        model_url = 'https://zenodo.org/record/6221127/files/w2v2-L-robust-12.6bc4a7fd-1.1.0.zip'
-        model_root = self.util.config_val('FEATS', 'aud.model', './audmodel/')
-        if not os.path.isdir(model_root):
-            cache_root = audeer.mkdir('cache')
-            model_root = audeer.mkdir(model_root)
-            archive_path = audeer.download_url(model_url, cache_root, verbose=True)
-            audeer.extract_archive(archive_path, model_root)
-        device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.model = audonnx.load(model_root, device=device)
-
-
-    def extract(self):
-        """Extract the features based on the initialized dataset or re-open them when found on disk."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        extract = eval(self.util.config_val('FEATS', 'needs_feature_extraction', 'False'))
-        no_reuse = eval(self.util.config_val('FEATS', 'no_reuse', 'False'))
-        if no_reuse or extract or not os.path.isfile(storage):
-            self.util.debug('extracting audmodel embeddings, this might take a while...')
-            hidden_states = audinterface.Feature(
-                self.model.labels('hidden_states'),
-                process_func=self.model,
-                process_func_args={
-                    'outputs': 'hidden_states',
-                },
-                sampling_rate=16000,    
-                resample=True,    
-                num_workers=5,
-                verbose=True,
-            )
-            self.df = hidden_states.process_index(self.data_df.index)
-            self.util.write_store(self.df, storage, store_format)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'False'
-            except KeyError:
-                pass
-        else:
-            self.util.debug('reusing extracted audmodel features.')
-            self.df = self.util.get_store(storage, store_format)
-
-
-    def extract_sample(self, signal, sr):
-        result = self.model(signal, sr)
-        return np.asarray(result['hidden_states'].flatten())

nkululeko/feats_audmodel_dim.py

@@ -1,63 +0,0 @@
-# feats_audmodel_dim.py
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import audeer
-import nkululeko.glob_conf as glob_conf
-import audonnx
-import numpy as np
-import audinterface
-
-class AudModelDimSet(Featureset):
-    """
-        Emotional dimensions from the wav2vec2. based model finetuned on MSPPodcast emotions, described in the paper
-        "Dawn of the transformer era in speech emotion recognition: closing the valence gap"
-        https://arxiv.org/abs/2203.07378
-    """
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)
-        model_url = 'https://zenodo.org/record/6221127/files/w2v2-L-robust-12.6bc4a7fd-1.1.0.zip'
-        model_root = self.util.config_val('FEATS', 'aud.model', './audmodel/')
-        if not os.path.isdir(model_root):
-            cache_root = audeer.mkdir('cache')
-            model_root = audeer.mkdir(model_root)
-            archive_path = audeer.download_url(model_url, cache_root, verbose=True)
-            audeer.extract_archive(archive_path, model_root)
-        device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.model = audonnx.load(model_root, device=device)
-
-
-    def extract(self):
-        """Extract the features based on the initialized dataset or re-open them when found on disk."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        extract = eval(self.util.config_val('FEATS', 'needs_feature_extraction', 'False'))
-        no_reuse = eval(self.util.config_val('FEATS', 'no_reuse', 'False'))
-        if no_reuse or extract or not os.path.isfile(storage):
-            self.util.debug('extracting audmodel dimensions, this might take a while...')
-            logits = audinterface.Feature(
-                self.model.labels('logits'),
-                process_func=self.model,
-                process_func_args={
-                    'outputs': 'logits',
-                },
-                sampling_rate=16000,    
-                resample=True,    
-                num_workers=5,
-                verbose=True,
-            )
-            self.df = logits.process_index(self.data_df.index)
-            self.util.write_store(self.df, storage, store_format)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'False'
-            except KeyError:
-                pass
-        else:
-            self.util.debug('reusing extracted audmodel dimensions.')
-            self.df = self.util.get_store(storage, store_format)
-
-
-    def extract_sample(self, signal, sr):
-        result = self.model(signal, sr)
-        return np.asarray(result['hidden_states'].flatten())

nkululeko/feats_clap.py

@@ -1,74 +0,0 @@
-# feats_clap.py
-
-from nkululeko.util import Util
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import os
-import nkululeko.glob_conf as glob_conf
-import laion_clap
-import audiofile
-
-class Clap(Featureset):
-    """Class to extract laion's clap embeddings (https://github.com/LAION-AI/CLAP)"""
-
-    def __init__(self, name, data_df):
-        """Constructor. is_train is needed to distinguish from test/dev sets, because they use the codebook from the training"""
-        super().__init__(name, data_df)
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.model_initialized = False
-
-
-
-    def init_model(self):
-        # load model
-        self.util.debug('loading clap model...')
-        self.model = laion_clap.CLAP_Module(enable_fusion=False)
-        self.model.load_ckpt() # download the default pretrained checkpoint.
-        print(f'loaded clap model')
-
-
-    def extract(self):
-        """Extract the features or load them from disk if present."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        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 clap 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(self.data_df.index.to_list()):
-                signal, sampling_rate = audiofile.read(file, offset=start.total_seconds(), duration=(end-start).total_seconds(), always_2d=True)
-                emb = self.get_embeddings(signal, sampling_rate)
-                emb_series[idx] = emb
-                if idx%10==0:
-                    self.util.debug(f'Clap: {idx} of {length} done')
-            self.df = pd.DataFrame(emb_series.values.tolist(), index=self.data_df.index) 
-            self.util.write_store(self.df, storage, store_format)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'false'
-            except KeyError:
-                pass
-        else:
-            self.util.debug('reusing extracted wav2vec2 embeddings')
-            self.df = self.util.get_store(storage, store_format)
-            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):
-        tmp_audio_name = ['clap_audio_tmp.wav']
-        audiofile.write(tmp_audio_name[0], signal, 48000)
-        audio_embed = self.model.get_audio_embedding_from_filelist(x = tmp_audio_name, use_tensor=False)
-        return audio_embed[0]
-    
-    def extract_sample(self, signal, sr):
-        self.init_model()
-        feats = self.get_embeddings(signal, sr)
-        return feats

nkululeko/feats_import.py

@@ -1,44 +0,0 @@
-# feats_import.py
-
-from nkululeko.util import Util
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import audformat
-
-class Importset(Featureset):
-    """Class to import features that have been compiled elsewhere"""
-
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)
-
-    def extract(self):
-        """Import the features or load them from disk if present."""
-        store = self.util.get_path('store')
-        storage = f'{store}{self.name}.pkl'
-        extract = eval(self.util.config_val('FEATS', 'needs_feature_extraction', False))
-        no_reuse = eval(self.util.config_val('FEATS', 'no_reuse', 'False'))
-        feat_import_file = self.util.config_val('FEATS', 'import_file', False)
-        if not os.path.isfile(feat_import_file):
-            self.util.warn(f'no import file: {feat_import_file}')
-        if extract or no_reuse or not os.path.isfile(storage):
-            self.util.debug(f'importing features for {self.name}')
-            # df = pd.read_csv(feat_import_file, sep=',', header=0, 
-            #     index_col=['file', 'start', 'end'])
-            df = audformat.utils.read_csv(feat_import_file)
-            # scale features before use?
-            # from sklearn.preprocessing import StandardScaler
-            # scaler = StandardScaler()
-            # scaled_features = scaler.fit_transform(df.values)
-            # df = pd.DataFrame(scaled_features, index=df.index, columns=df.columns)
-            # use only the rows from the data index
-            #df = self.data_df.join(df).drop(columns=self.data_df.columns)
-            df = df.loc[self.data_df.index]
-            #df = pd.concat([self.data_df, df], axis=1, join="inner").drop(columns=self.data_df.columns)
-            # in any case, store to disk for later use
-            df.to_pickle(storage) 
-            # and assign to be the "official" feature set
-            self.df = df           
-        else:
-            self.util.debug('reusing imported features.')
-            self.df = pd.read_pickle(storage)

nkululeko/feats_mld.py

@@ -1,47 +0,0 @@
-# mld_fset.py
-from nkululeko.featureset import Featureset
-import sys
-import os
-import pandas as pd
-import numpy as np
-from nkululeko.util import Util 
-import nkululeko.glob_conf as glob_conf
-
-class MLD_set(Featureset):
-
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)   
-        mld_path = self.util.config_val('FEATS', 'mld.model', None)
-        sys.path.append(mld_path)
-
-    def extract(self):
-        store = self.util.get_path('store')
-        storage = f'{store}{self.name}.pkl'
-        no_reuse = eval(self.util.config_val('FEATS', 'no_reuse', 'False'))
-        if no_reuse:
-            os.remove(storage)
-        if not os.path.isfile(storage):
-            self.util.debug('extracting midleveldescriptor features, this might take a while...')
-        else:
-            self.util.debug('reusing previously extracted midleveldescriptor features')
-        import midlevel_descriptors as mld
-        fex_mld = mld.MLD()
-        self.df = fex_mld.extract_from_index(index=self.data_df, cache_path=storage)
-        self.util.debug(f'MLD feats shape: {self.df.shape}')
-        # shouldn't happen
-        # replace NANa with column means values
-        self.util.debug('MLD extractor: checking for NANs...')
-        for i, col in enumerate(self.df.columns):
-            if self.df[col].isnull().values.any():
-                self.util.debug(f'{col} includes {self.df[col].isnull().sum()} nan, inserting mean values')
-                self.df[col] = self.df[col].fillna(self.df[col].mean())
-
-        try:
-            # use only samples that have a minimum number of syllables
-            min_syls = int(glob_conf.config['FEATS']['min_syls'])
-            self.df = self.df[self.df['hld_nSyl']>=min_syls]
-        except KeyError:
-            pass
-        if self.df.isna().to_numpy().any():
-            self.util.error('feats 0: NANs exist')
-        self.df = self.df.astype(float)

nkululeko/feats_mos.py

@@ -1,92 +0,0 @@
-""" feats_mos.py
-predict MOS (mean opinion score)
-
-adapted from
-from https://pytorch.org/audio/main/tutorials/squim_tutorial.html#sphx-glr-tutorials-squim-tutorial-py
-paper: https://arxiv.org/pdf/2304.01448.pdf
-
-needs 
-pip uninstall -y torch torchvision torchaudio
-pip install --pre torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu
-
-"""
-from nkululeko.util import Util
-from nkululeko.featureset import Featureset
-import os
-import pandas as pd
-import os
-import nkululeko.glob_conf as glob_conf
-import audiofile
-import torch
-import torchaudio
-from torchaudio.pipelines import SQUIM_SUBJECTIVE
-from torchaudio.utils import download_asset
-
-class MOSSet(Featureset):
-    """Class to predict MOS (mean opinion score)
-    
-    """
-
-    def __init__(self, name, data_df):
-        """Constructor. is_train is needed to distinguish from test/dev sets, because they use the codebook from the training"""
-        super().__init__(name, data_df)
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.model_initialized = False
-
-
-    def init_model(self):
-        # load model
-        self.util.debug('loading MOS model...')
-        self.subjective_model = SQUIM_SUBJECTIVE.get_model()
-        NMR_SPEECH = download_asset("tutorial-assets/ctc-decoding/1688-142285-0007.wav")
-        self.WAVEFORM_NMR, SAMPLE_RATE_NMR = torchaudio.load(NMR_SPEECH)
-        self.model_initialized = True
-
-    def extract(self):
-        """Extract the features or load them from disk if present."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        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('predicting MOS, 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(self.data_df.index.to_list()):
-                signal, sampling_rate = audiofile.read(file, offset=start.total_seconds(), duration=(end-start).total_seconds(), always_2d=True)
-                emb = self.get_embeddings(signal, sampling_rate)
-                emb_series[idx] = emb
-                if idx%10==0:
-                    self.util.debug(f'MOS: {idx} of {length} done')
-            self.df = pd.DataFrame(emb_series.values.tolist(), index=self.data_df.index) 
-            self.df.columns = ['mos']
-            self.util.write_store(self.df, storage, store_format)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'false'
-            except KeyError:
-                pass
-        else:
-            self.util.debug('reusing predicted MOS values')
-            self.df = self.util.get_store(storage, store_format)
-            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):
-        tmp_audio_name = 'mos_audio_tmp.wav'
-        audiofile.write(tmp_audio_name, signal, sampling_rate)
-        WAVEFORM_SPEECH, SAMPLE_RATE_SPEECH = torchaudio.load(tmp_audio_name)
-        with torch.no_grad():
-            mos = self.subjective_model(WAVEFORM_SPEECH, self.WAVEFORM_NMR)
-        return float(mos[0].numpy())
-    
-    
-    def extract_sample(self, signal, sr):
-        self.init_model()
-        feats = self.get_embeddings(signal, sr)
-        return feats

nkululeko/feats_opensmile.py

@@ -1,84 +0,0 @@
-# opensmileset.py
-from nkululeko.featureset import Featureset
-import opensmile
-import os
-import pandas as pd
-import nkululeko.glob_conf as glob_conf
-import ast
-
-class Opensmileset(Featureset):
-
-    def __init__(self, name, data_df):
-        super().__init__(name, data_df)
-        self.featset = self.util.config_val('FEATS', 'set', 'eGeMAPSv02')
-        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}')        
-        self.featlevel = self.util.config_val('FEATS', 'level', 'functionals')
-        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}')        
-
-
-    def extract(self):
-        """Extract the features based on the initialized dataset or re-open them when found on disk."""
-        store = self.util.get_path('store')
-        store_format = self.util.config_val('FEATS', 'store_format', 'pkl')
-        storage = f'{store}{self.name}.{store_format}'
-        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...')
-            smile = opensmile.Smile(
-            feature_set= self.feature_set,
-            feature_level=self.feature_level,
-            num_workers=5,
-            verbose=True,)
-            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)
-            try:
-                glob_conf.config['DATA']['needs_feature_extraction'] = 'False'
-            except KeyError:
-                pass
-        else:
-            self.util.debug(f'reusing extracted OS features: {storage}.')
-            self.df = self.util.get_store(storage, store_format)
-
-    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(f'new feats shape after selecting opensmile features: {self.df.shape}')
-        except KeyError:
-            pass