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

nkululeko/ap_arousal.py

@@ -1,30 +0,0 @@
-""""
-A predictor for emotional arousal.
-Currently based on audEERING's emotional dimension model.
-"""
-from nkululeko.util import Util
-from nkululeko.feature_extractor import FeatureExtractor
-import ast
-import nkululeko.glob_conf as glob_conf
-class ArousalPredictor:
-    """
-    ArousalPredictor
-    predicting arousal with the audEERING emotional dimension model
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('arousalPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'predicting arousal for {split_selection} samples')
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['auddim'], feats_name, split_selection)
-        pred_df = self.feature_extractor.extract()
-        pred_vals = pred_df.arousal * 1000
-        return_df = self.df.copy()
-        return_df['arousal_pred'] = pred_vals.astype('int')/1000
-
-        return return_df
-

nkululeko/ap_dominance.py

@@ -1,29 +0,0 @@
-"""
-A predictor for emotional dominance.
-Currently based on audEERING's emotional dimension model.
-"""
-
-from nkululeko.util import Util
-from nkululeko.feature_extractor import FeatureExtractor
-import ast
-import nkululeko.glob_conf as glob_conf
-class DominancePredictor:
-    """
-    DominancePredictor
-    predicting dominance with the audEERING emotional dimension model
-    """
-
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('dominancePredictor')
-
-    def predict(self, split_selection):
-        self.util.debug(f'predicting dominance for {split_selection} samples')
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['auddim'], feats_name, split_selection)
-        pred_df = self.feature_extractor.extract()
-        pred_vals = pred_df.dominance * 1000
-        return_df = self.df.copy()
-        return_df['dominance_pred'] = pred_vals.astype('int')/1000
-
-        return return_df

nkululeko/ap_gender.py

@@ -1,29 +0,0 @@
-""""
-A predictor for biological sex.
-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 GenderPredictor:
-    """
-    GenderPredictor
-    predicting gender with the audEERING agender model
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('genderPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'predicting gender 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_gender = agender_df.drop('age', axis=1).idxmax(axis=1)
-        return_df = self.df.copy()
-        return_df['gender_pred'] = pred_gender
-        return return_df
-

nkululeko/ap_mos.py

@@ -1,35 +0,0 @@
-""""
-A predictor for MOS - mean opinion score.
-"""
-from nkululeko.util import Util
-import ast
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-import numpy as np
-
-
-class MOSPredictor:
-    """
-    MOSPredictor
-    predicting MOS
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('mosPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'estimating MOS for {split_selection} samples')
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['mos'], feats_name, split_selection)
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_snr = result_df.mos * 100
-        return_df['mos_pred'] = pred_snr.astype('int')/100
-        return return_df
-

nkululeko/ap_pesq.py

@@ -1,35 +0,0 @@
-""""
-A predictor for PESQ - Perceptual Evaluation of Speech Quality.
-"""
-from nkululeko.util import Util
-import ast
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-import numpy as np
-
-
-class PESQPredictor:
-    """
-    PESQPredictor
-    predicting PESQ
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('pesqPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'estimating PESQ for {split_selection} samples')
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['squim'], feats_name, split_selection)
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_vals = result_df.pesq * 100
-        return_df['pesq_pred'] = pred_vals.astype('int')/100
-        return return_df
-

nkululeko/ap_sdr.py

@@ -1,36 +0,0 @@
-""""
-A predictor for SDR - Signal to Distortion Ratio.
-as estimated by Scale-Invariant Signal-to-Distortion Ratio (SI-SDR) 
-"""
-from nkululeko.util import Util
-import ast
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-import numpy as np
-
-
-class SDRPredictor:
-    """
-    SDRPredictor
-    predicting SDR
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('snrPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'estimating SDR for {split_selection} samples')
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['squim'], feats_name, split_selection)
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_vals = result_df.sdr * 100
-        return_df['sdr_pred'] = pred_vals.astype('int')/100
-        return return_df
-

nkululeko/ap_snr.py

@@ -1,35 +0,0 @@
-""""
-A predictor for SNR - signal-to-noise ratio.
-"""
-from nkululeko.util import Util
-import ast
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-import numpy as np
-
-
-class SNRPredictor:
-    """
-    SNRPredictor
-    predicting snr
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('snrPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'estimating SNR for {split_selection} samples')
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['snr'], feats_name, split_selection)
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_snr = result_df.snr * 100
-        return_df['snr_pred'] = pred_snr.astype('int')/100
-        return return_df
-

nkululeko/ap_stoi.py

@@ -1,34 +0,0 @@
-""""
-A predictor for STOI - Short-Time Objective Intelligibility (STOI)
-"""
-from nkululeko.util import Util
-import ast
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-import numpy as np
-
-
-class STOIPredictor:
-    """
-    STOIPredictor
-    predicting STOI Short-Time Objective Intelligibility (STOI)
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('stoiPredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'estimating STOI for {split_selection} samples')
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['squim'], feats_name, split_selection)
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_vals = result_df.stoi * 100
-        return_df['stoi_pred'] = pred_vals.astype('int')/100
-        return return_df

nkululeko/ap_valence.py

@@ -1,30 +0,0 @@
-""""
-A predictor for emotional valence.
-Currently based on audEERING's emotional dimension model.
-"""
-from nkululeko.util import Util
-from nkululeko.feature_extractor import FeatureExtractor
-import ast
-import nkululeko.glob_conf as glob_conf
-class ValencePredictor:
-    """
-    ValencePredictor
-    predicting valence with the audEERING emotional dimension model
-    
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('valencePredictor')
-
-
-    def predict(self, split_selection):
-        self.util.debug(f'predicting valence for {split_selection} samples')
-        feats_name = "_".join(ast.literal_eval(glob_conf.config['DATA']['databases']))
-        self.feature_extractor = FeatureExtractor(self.df, ['auddim'], feats_name, split_selection)
-        pred_df = self.feature_extractor.extract()
-        pred_vals = pred_df.valence * 1000
-        return_df = self.df.copy()
-        return_df['valence_pred'] = pred_vals.astype('int')/1000
-
-        return return_df
-

nkululeko/augmenter.py

@@ -1,64 +0,0 @@
-# augmenter.py
-import pandas as pd
-from nkululeko.util import Util 
-from audiomentations import Compose, AddGaussianNoise, AddGaussianSNR, TimeStretch, PitchShift, Shift
-import numpy as np
-import audiofile
-import os
-from audformat.utils import map_file_path
-import audeer
-
-class Augmenter:
-    """
-        augmenting the train split
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('augmenter')
-        # Define a standard transformation that randomly add augmentations to files
-        self.audioment = Compose([
-            AddGaussianNoise(min_amplitude=0.001, max_amplitude=0.015, p=0.5),
-            AddGaussianSNR(min_snr_db=10, max_snr_db=40, p=0.5),
-            TimeStretch(min_rate=0.8, max_rate=1.25, p=0.5),
-            PitchShift(min_semitones=-4, max_semitones=4, p=0.5),
-            Shift(min_fraction=-0.5, max_fraction=0.5, p=0.5),
-        ])
-
-    def changepath(self, fp, np):
-#        parent = os.path.dirname(fp).split('/')[-1]
-        fullpath = os.path.dirname(fp)
- #       newpath = f'{np}{parent}'
- #       audeer.mkdir(newpath)
-        return fp.replace(fullpath, np)
-
-    def augment(self, sample_selection):
-        """
-        augment the training files and return a dataframe with new files index.
-        """
-        files = self.df.index.get_level_values(0).values
-        store = self.util.get_path('store')
-        filepath = f'{store}augmentations/'
-        audeer.mkdir(filepath)
-        self.util.debug(f'augmenting {sample_selection} samples to {filepath}')
-        newpath = ''
-        for i, f in enumerate(files):
-            signal, sr = audiofile.read(f)
-            filename = os.path.basename(f)
-            parent = os.path.dirname(f).split('/')[-1]
-            sig_aug = self.audioment(samples=signal, sample_rate=sr)
-            newpath = f'{filepath}/{parent}/'
-            audeer.mkdir(newpath)
-            audiofile.write(f'{newpath}{filename}', signal=sig_aug, 
-                            sampling_rate=sr)
-            if i%10 == 0:
-                print(f'augmented {i} of {len(files)}')
-        df_ret = self.df.copy()
-        df_ret = df_ret.set_index(map_file_path(df_ret.index, 
-            lambda x: self.changepath(x, newpath)))
-        aug_db_filename = self.util.config_val('DATA', 
-                                               'augment_result', 'augment.csv')
-        target = self.util.config_val('DATA', 'target', 'emotion')
-        df_ret[target] = df_ret['class_label']
-        df_ret = df_ret.drop(columns=['class_label'])
-        df_ret.to_csv(aug_db_filename)
-        return df_ret