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

nkululeko/model_mlp_regression.py

@@ -1,197 +0,0 @@
-# model_mlp.py
-from nkululeko.util import Util 
-import nkululeko.glob_conf as glob_conf
-from nkululeko.model import Model
-from nkululeko.reporter import Reporter
-import torch
-import ast
-import numpy as np
-from sklearn.metrics import mean_squared_error
-from collections import OrderedDict
-from nkululeko.loss_ccc import ConcordanceCorCoeff
-import os
-
-class MLP_Reg_model(Model):
-    """MLP = multi layer perceptron"""
-
-    is_classifier = False
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        """Constructor taking the configuration and all dataframes"""
-        super().__init__(df_train, df_test, feats_train, feats_test)
-        self.target = glob_conf.config['DATA']['target']
-        labels = ast.literal_eval(glob_conf.config['DATA']['labels'])
-        self.class_num = len(labels)
-        # set up loss criterion
-        criterion = self.util.config_val('MODEL', 'loss', 'mse')
-        if criterion == 'mse':
-            self.criterion = torch.nn.MSELoss()
-        elif criterion == '1-ccc':
-            self.criterion = ConcordanceCorCoeff()
-        else:
-            self.util.error(f'unknown loss function: {criterion}')
-        self.util.debug(f'training model with {criterion} loss function')
-        # set up the model
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        layers_string = glob_conf.config['MODEL']['layers']
-        self.util.debug(f'using layers {layers_string}')
-        layers = ast.literal_eval(layers_string)
-        drop = self.util.config_val('MODEL', 'drop', False)
-        if drop:
-            self.util.debug(f'training with dropout: {drop}')
-        self.model = self.MLP(feats_train.shape[1], layers, 1, drop).to(self.device)
-        self.learning_rate = float(self.util.config_val('MODEL', 'learning_rate', 0.0001))
-        # set up regularization
-        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learning_rate)
-        # batch size
-        self.batch_size = int(self.util.config_val('MODEL', 'batch_size', 8))
-        # number of parallel processes
-        self.num_workers = int(self.util.config_val('MODEL', 'num_workers', 5))
-        # set up the data_loaders
-        if feats_train.isna().to_numpy().any():
-            self.util.debug(f'Model, train: replacing {feats_train.isna().sum().sum()} NANs with 0')
-            feats_train = feats_train.fillna(0)
-        if feats_test.isna().to_numpy().any():
-            self.util.debug(f'Model, test: replacing {feats_test.isna().sum().sum()} NANs with 0')
-            feats_test = feats_test.fillna(0)
-        self.trainloader = self.get_loader(feats_train, df_train, True)
-        self.testloader = self.get_loader(feats_test, df_test, False)
-
-    def set_testdata(self, data_df, feats_df):
-        self.testloader = self.get_loader(feats_df, data_df, False)
-
-    def train(self):
-        loss = self.train_epoch(self.model, self.trainloader, self.device, self.optimizer, self.criterion)
-        return loss
-
-    def predict(self):        
-        _, truths, predictions = self.evaluate_model(self.model, self.testloader, self.device)
-        result, _, _ = self.evaluate_model(self.model, self.trainloader, self.device)
-        report = Reporter(truths.numpy(), predictions.numpy(), self.run, self.epoch)
-        try:
-            report.result.loss = self.loss
-        except AttributeError: # if the model was loaded from disk the loss is unknown
-            pass 
-        report.result.train = result
-        return report
-
-    def get_loader(self, df_x, df_y, shuffle):
-        data_set = self.Dataset(df_y, df_x, self.target)
-        loader = torch.utils.data.DataLoader(
-            dataset=data_set,
-            batch_size=self.batch_size,
-            shuffle=shuffle,
-            num_workers=self.num_workers
-        )
-        return loader
-
-    class Dataset(torch.utils.data.Dataset):
-        def __init__(self, df, features,
-                    label: str):
-            super().__init__()
-            self.df = df
-            self.df_features = features
-            self.label = label
-        def __len__(self):
-            return len(self.df)
-
-        def __getitem__(self, item):
-            index = self.df.index[item]
-            features = self.df_features.loc[index, :].values.astype('float32').squeeze()
-            labels = np.array([self.df.loc[index, self.label]]).astype('float32').squeeze()
-            return features, labels
-
-
-    class MLP(torch.nn.Module):
-        def __init__(self, i, layers, o, drop):
-            super().__init__()
-            sorted_layers = sorted(layers.items(), key=lambda x: x[1])
-            layers = OrderedDict()
-            layers['0'] = torch.nn.Linear(i, sorted_layers[0][1])
-            layers['0_r'] = torch.nn.ReLU()
-            for i in range(0, len(sorted_layers)-1):         
-                layers[str(i+1)] = torch.nn.Linear(sorted_layers[i][1], sorted_layers[i+1][1])
-                if drop:
-                    layers[str(i)+'_d'] = torch.nn.Dropout(float(drop))
-                layers[str(i)+'_r'] = torch.nn.ReLU()
-            layers[str(len(sorted_layers)+1)] = torch.nn.Linear(sorted_layers[-1][1], o)
-            self.linear = torch.nn.Sequential(layers)
-        def forward(self, x):
-            # x: (batch_size, channels, samples)
-            x = x.squeeze(dim=1).float()
-            return self.linear(x)
-
-
-    def train_epoch(self, model, loader, device, optimizer, criterion):
-        # first check if the model already has been trained
-        # if os.path.isfile(self.store_path):
-        #     self.load(self.run, self.epoch)
-        #     self.util.debug(f'reusing model: {self.store_path}')
-        #     return
-        self.model.train()
-        losses = []
-        for features, labels in loader:
-            logits = model(features.to(device)).reshape(-1)
-            loss = criterion(logits, labels.to(device))
-            #print(f'loss: {loss.item()}')
-            losses.append(loss.item())
-            optimizer.zero_grad()
-            loss.backward()
-            optimizer.step()
-        self.loss = (np.asarray(losses)).mean()
-
-    def evaluate_model(self, model, loader, device):
-        logits = torch.zeros(len(loader.dataset))
-        targets = torch.zeros(len(loader.dataset))
-        model.eval()
-        with torch.no_grad():
-            for index, (features, labels) in enumerate(loader):
-                start_index = index * loader.batch_size
-                end_index = (index + 1) * loader.batch_size
-                if end_index > len(loader.dataset):
-                    end_index = len(loader.dataset)
-                logits[start_index:end_index] = model(features.to(device)).reshape(-1)
-                targets[start_index:end_index] = labels
-
-        predictions = logits
-        measure = self.util.config_val('MODEL', 'measure', 'mse')
-        if measure == 'mse':
-            result = mean_squared_error(targets.numpy(), predictions.numpy())
-        elif measure == 'ccc':
-            result = Reporter.ccc(targets.numpy(), predictions.numpy())
-        else:
-            self.util.error(f'unknown measure: {measure}')
-        return result, targets, predictions
-
-    def store(self):
-        torch.save(self.model.state_dict(), self.store_path)
-        
-    def load(self, run, epoch):
-        self.set_id(run, epoch)
-        dir = self.util.get_path('model_dir')
-        name = f'{self.util.get_exp_name(only_train=True)}_{run}_{epoch:03d}.model'
-        self.store_path = dir+name
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        layers = ast.literal_eval(glob_conf.config['MODEL']['layers'])
-        drop = self.util.config_val('MODEL', 'drop', False)
-        if drop:
-            self.util.debug(f'training with dropout: {drop}')
-        self.model = self.MLP(self.feats_train.shape[1], layers, 1, drop).to(self.device)
-        self.model.load_state_dict(torch.load(dir+name))
-        self.model.eval()
-        
-    def load_path(self, path, run, epoch):
-        self.set_id(run, epoch)
-        with open(path, 'rb') as handle:
-            self.device = self.util.config_val('MODEL', 'device', 'cpu')
-            layers = ast.literal_eval(glob_conf.config['MODEL']['layers'])
-            self.store_path = path
-            drop = self.util.config_val('MODEL', 'drop', False)
-            if drop:
-                self.util.debug(f'training with dropout: {drop}')
-            self.model = self.MLP(self.feats_train.shape[1], layers, self.class_num, drop).to(self.device)
-            self.model.load_state_dict(torch.load(self.store_path))
-            self.model.eval()
-    def predict_sample(self, features):
-        """Predict one sample"""
-        self.util.error('model_mlp_regression: predicting one sample not implemented yet')

nkululeko/model_svm.py

@@ -1,18 +0,0 @@
-# model_svm.py
-
-from sklearn import svm
-from nkululeko.model import Model
-
-class SVM_model(Model):
-    """An SVM model"""
-
-    is_classifier = True
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        super().__init__(df_train, df_test, feats_train, feats_test)
-        c = float(self.util.config_val('MODEL', 'C_val', '0.001'))
-        self.clf = svm.SVC(kernel='linear', C=c, gamma='auto') # set up the classifier
-
-    def set_C(self, c):
-        """Set the C parameter"""
-        self.clf.C = c

nkululeko/model_svr.py

@@ -1,18 +0,0 @@
-# svrmodel.py
-
-from sklearn import svm
-from nkululeko.model import Model
-
-class SVR_model(Model):
-    """An SVR model"""
-
-    is_classifier = False
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        super().__init__(df_train, df_test, feats_train, feats_test)
-        c = float(self.util.config_val('MODEL', 'C_val', '0.001'))
-        self.clf = svm.SVR(kernel='rbf', C=c) # set up the classifier
-
-    def set_C(self, c):
-        """Set the C parameter"""
-        self.clf.C = c

nkululeko/model_tree.py

@@ -1,14 +0,0 @@
-# model_tree.py
-
-from sklearn.tree import DecisionTreeClassifier
-from nkululeko.model import Model
-
-class Tree_model(Model):
-    """An Tree model"""
-
-    is_classifier = True
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        super().__init__(df_train, df_test, feats_train, feats_test)
-        self.clf = DecisionTreeClassifier() # set up the classifier
-

nkululeko/model_tree_reg.py

@@ -1,14 +0,0 @@
-# model_tree_reg.py
-
-from sklearn.tree import DecisionTreeRegressor
-from nkululeko.model import Model
-
-class Tree_reg_model(Model):
-
-    is_classifier = False
-
-    """An Tree model"""
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        super().__init__(df_train, df_test, feats_train, feats_test)
-        self.clf = DecisionTreeRegressor() # set up the classifier
-

nkululeko/model_xgb.py

@@ -1,12 +0,0 @@
-# xgbmodel.py
-
-from xgboost import XGBClassifier
-from nkululeko.model import Model
-
-class XGB_model(Model):
-    """An XGBoost model"""
-
-    is_classifier = True
-
-    clf = XGBClassifier(use_label_encoder=False) # set up the classifier
-

nkululeko/model_xgr.py

@@ -1,12 +0,0 @@
-# xgrmodel.py
-
-from xgboost.sklearn import XGBRegressor
-from nkululeko.model import Model
-
-class XGR_model(Model):
-    """An XGBoost model"""
-
-    is_classifier = False
-
-    clf = XGBRegressor(use_label_encoder=False) # set up the regressor
-

nkululeko/randomsplicer.py

@@ -1,76 +0,0 @@
-# randomsplicer.py
-
-"""
-Code originally by Oliver Pauly
-
-Based on an idea by Klaus Scherer
-
-K. R. Scherer, “Randomized splicing: A note on a simple technique for masking speech content” 
-Journal of Experimental Research in Personality, vol. 5, pp. 155–159, 1971.
-
-Evaluated in:
-F. Burkhardt, Anna Derington, Matthias Kahlau, Klaus Scherer, Florian Eyben and Björn Schuller: Masking Speech Contents by Random Splicing: is Emotional Expression Preserved?, Proc. ICASSP, 2023
-
-"""
-
-import pandas as pd
-from nkululeko.util import Util 
-import nkululeko.randomsplicing as rsp
-import numpy as np
-import audiofile as af
-import os
-from audformat.utils import map_file_path
-import audeer
-
-class Randomsplicer:
-    """
-        augmenting the train split
-    """
-    def __init__(self, df):
-        self.df = df
-        self.util = Util('randomsplicer')
-
-    def changepath(self, fp, np):
-        fullpath = os.path.dirname(fp)
-        return fp.replace(fullpath, np)
-
-    def run(self, sample_selection):
-        """
-        random splice the selected samples and return a dataframe with new files index.
-            adjustable parameters:
-            * p_reverse: probability of some samples to be in reverse order (default: 0.3)
-            * top_db: top db level for silence to be recognized (default: 12)   
-        """
-
-        p_reverse=0.3
-        top_db=12
-
-        files = self.df.index.get_level_values(0).values
-        store = self.util.get_path('store')
-        filepath = f'{store}randomspliced/'
-        audeer.mkdir(filepath)
-        self.util.debug(f'random splicing {sample_selection} samples to {filepath}')
-        newpath = ''
-        for i, f in enumerate(files):
-            signal, sr = af.read(f)
-            filename = os.path.basename(f)
-            parent = os.path.dirname(f).split('/')[-1]
-            sig_new = rsp.random_splicing(
-                signal, sr,
-                p_reverse=p_reverse,
-                top_db=top_db,
-                )
-
-            newpath = f'{filepath}/{parent}/'
-            audeer.mkdir(newpath)
-            af.write(f'{newpath}{filename}', signal=sig_new, sampling_rate=sr)
-            if i%10==0:
-                print(f'random spliced {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)))
-        db_filename = self.util.config_val('DATA', 'random_splice_result', 'random_spliced.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(db_filename)
-        return df_ret

nkululeko/randomsplicing.py

@@ -1,74 +0,0 @@
-"""
-Code originally by Oliver Pauly
-
-Based on an idea by Klaus Scherer
-
-K. R. Scherer, “Randomized splicing: A note on a simple technique for masking speech content” 
-Journal of Experimental Research in Personality, vol. 5, pp. 155–159, 1971.
-
-Evaluated in:
-F. Burkhardt, Anna Derington, Matthias Kahlau, Klaus Scherer, Florian Eyben and Björn Schuller: Masking Speech Contents by Random Splicing: is Emotional Expression Preserved?, Proc. ICASSP, 2023
-
-"""
-import numpy as np
-import librosa
-import audiofile as af
-
-def random_splicing(
-    signal, sr,
-    p_reverse=0.0,
-    top_db=12,
-    ):
-    """
-    randomly splice the signal and re-arrange.    
-    
-    p_reverse: probability of some samples to be in reverse order
-    top_db:  top db level for silence to be recognized
-    
-    """
-    signal /= np.max(abs(signal))
-
-    indices = split_wav_naive(signal, top_db=top_db)
-
-    np.random.shuffle(indices) 
-
-    wav_spliced = remix_random_reverse(signal, indices, p_reverse=p_reverse)
-        
-    return wav_spliced
-
-
-def split_wav_naive(wav, top_db=12):
-      
-    indices = librosa.effects.split(wav, top_db=top_db)
-    
-    indices = np.array(indices)
-    # (re)add the silence-segments
-    indices = indices.repeat(2)[1:-1].reshape((-1, 2))
-    # add first segment
-    indices = np.vstack(((0, indices[0][0]), indices))
-    # add last segment
-    indices = np.vstack((indices, [indices[-1][-1], wav.shape[0]]))
-
-    return indices
-
-
-def remix_random_reverse(wav, indices, p_reverse=0):
-    
-    import random
-
-    wav_remix = []
-    
-    for seg in indices:
-        
-        start = seg[0]
-        end = seg[1]
-        wav_seg = wav[start:end]
-            
-        if np.random.rand(1)[0] <= p_reverse:
-            wav_seg = wav_seg[::-1]
-    
-        wav_remix.append(wav_seg)
-        
-    wav_remix = np.hstack(wav_remix)
-    
-    return wav_remix

nkululeko-0.59.1.dist-info/RECORD

@@ -1,82 +0,0 @@
-nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
-nkululeko/ap_age.py,sha256=ZpWtNpfqseK2JwD2ZeRXdEtXm9EKmaeYwdQ-r-e0FcM,1054
-nkululeko/ap_arousal.py,sha256=mYVHBdX4wmAjEZ9DvKBiVONJuDiiGN0Zn8HintV6OUQ,997
-nkululeko/ap_dominance.py,sha256=gwsQ8OMSTgY9oG26L9wk4qfgGjR_gyo66yiDNQ9PY5I,1006
-nkululeko/ap_gender.py,sha256=MfySaQNQEpV9GZCJm1vas_SIcXrCh7O5Q4X6AXVcQDE,983
-nkululeko/ap_mos.py,sha256=GByXFm4IpHDyxUHqF5hmqnZbX4LfdH2quHjxzcrlzg0,1079
-nkululeko/ap_pesq.py,sha256=5qKMnisQOrKiKqB_G2--KULoDPvyBKiJ69LIBmAnlTo,1112
-nkululeko/ap_sdr.py,sha256=eclDh9wzXYDiuqy5deIRB_h16wBnJ_J438UyZEC4Ejo,1160
-nkululeko/ap_snr.py,sha256=X5Pnl9PDOw-w1cJSmzKaPtCMEiQhko6pWd0YAGeGYjQ,1082
-nkululeko/ap_stoi.py,sha256=sx2KSGSjCsjgUvZPFlKALhbZlVg2aTdGmvil-iNSqVk,1157
-nkululeko/ap_valence.py,sha256=cyFrKRy68EU5gDiVg0_HxiwaKGbAJ9UuwuiXgVTalAU,997
-nkululeko/augment.py,sha256=ebv5QebGD8wLzXInvusjn4kFlET6-yXkYoF132BrubQ,1750
-nkululeko/augmenter.py,sha256=nOJPb7Ut4wLlEcla1JaUiLntksrZqfvq1mFOCexpT7Y,2584
-nkululeko/balancer.py,sha256=64ftZN68sMDfkvuovCDHpAHmSJgCO6Kdk9bwmpSisec,12
-nkululeko/cacheddataset.py,sha256=bSJ_SDg7TxL89YL_pJXp-sFvdUXJtHuBTd5KSTE4AkQ,955
-nkululeko/constants.py,sha256=BqCvUlzgpeRIc5r6IurUVStV5rCCTTLE18mSY_9KmDM,18
-nkululeko/dataset.py,sha256=pI4UYyR-H5ZeZBGXZqIOh1vGzPvzfp6yQx_cpQ-JIn8,20458
-nkululeko/dataset_csv.py,sha256=vsefSiAz_zodxoatvpX_H7l9GFdA8jDeRcRZX8yl4Vw,2120
-nkululeko/dataset_ravdess.py,sha256=pTt98sr4_egdUCv2fWepkZTlkQ6x3A2YshO_n302DNg,537
-nkululeko/demo.py,sha256=nGP3fUDXuW1ZF12AzMpzRWXct0rdqYRJVNgA9B_QWwA,1821
-nkululeko/demo_predictor.py,sha256=VVxE2lf5lTkAP5qElG5U2bK6SdDzQ2Jmf0Vn_yHpSro,2302
-nkululeko/estimate_snr.py,sha256=m3JZSRGXr2M9yVgovTSZ63rpho9hIUfHOXfAVRAHf1k,4186
-nkululeko/experiment.py,sha256=x_JACYeR1-OQtVi8sUTBPYTX8ONk2s6l51CVYgGn_hc,24872
-nkululeko/explore.py,sha256=aemOk5XYw7axQEJQfdABEUxN3img0NYSb8l6W-nDzZY,2090
-nkululeko/feats_agender.py,sha256=46DmyXVHKL7wH77j1W82ualUmPic93t8OAIL5q_yMXI,2750
-nkululeko/feats_agender_agender.py,sha256=Vwt3fynWHwmTMJtHu5ltDQhtW_VO3ImKqwGMNoxhIyI,2832
-nkululeko/feats_analyser.py,sha256=u11ZvuoKFqytGi1TNGEhnagLplNXX-wvqmB5Cb_tUIY,3837
-nkululeko/feats_audmodel.py,sha256=B1u4BMftKYHbtzf8kIAx2uQzzVcqpVJGIuH3S1hjU_c,2750
-nkululeko/feats_audmodel_dim.py,sha256=Pd_LXvjJTGb3MAuXiFo0_50BABJnm3IdxUVkRYLEY6c,2741
-nkululeko/feats_clap.py,sha256=CHOkNzdMNK5vDld69EsBeBTkyxn_hY1d3LyU2lO3mR0,3250
-nkululeko/feats_import.py,sha256=Gm-svzwNY8Qvdv91VjgjmAudroAi32v2gCC56USJtKA,2045
-nkululeko/feats_mld.py,sha256=6ErExKzDpfwoLwzBBNMeIZ2G5D2ovHA7UvKRqVdF-bo,1909
-nkululeko/feats_mos.py,sha256=xp51EWetc7d4pMrUP3z0j_9hErDNLMo5GetNDiItOMA,3887
-nkululeko/feats_opensmile.py,sha256=bp5f3iDzvw3XgB458dFHwqLuCL_WbZk8FOx41CWzyo0,3812
-nkululeko/feats_oxbow.py,sha256=lZLPXcUk7IcexM3O5kw-ekkYodfXE6QpS2QSHU1D6F8,4425
-nkululeko/feats_praat.py,sha256=BbjgpIO-dJ2GuVxQdaTtu8rRuaJ0dmFm9F3g_z_5SCA,3024
-nkululeko/feats_snr.py,sha256=BOhO0kDxyfnSTLA6gxSYilNkRGiXhamShZJNron8Z6g,2605
-nkululeko/feats_squim.py,sha256=9dzKVyuoN-VVetlFqs62BsV4xjrCQK-wtQ6Mek-NB3M,4029
-nkululeko/feats_trill.py,sha256=dydoLTVZnWeps_Ur0xWNhGdAw3PxA9yFCg6exTi2zhs,2934
-nkululeko/feats_wav2vec2.py,sha256=S63QmTiGlyEalO4HjacAh9KxOAVO80vZntG-Alk91WU,4005
-nkululeko/feature_extractor.py,sha256=AxPqhXFU9o42g6BGkjVWK7ZOXyKiTW8NJ6_QbT-dTPA,5115
-nkululeko/featureset.py,sha256=8zYafHU_nDYV89AukfNobltCxBuoIvvRIGEXPm0PCI0,1331
-nkululeko/feinberg_praat.py,sha256=fUrdVo1aJNitdG1L0sZRfIvGMJJdQwG3BXoAV5xjh5o,19472
-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/loss_ccc.py,sha256=BM2I6j_rjKlpua5gKbo81EAS3hhZK-ClBTqJHot9Ils,939
-nkululeko/loss_softf1loss.py,sha256=OPBH-HvHf6saZ9-W85qhi4hH6jj2E-wwKq2Jt_el8pI,1329
-nkululeko/model.py,sha256=wh8wd_5_Nk2y8onNrAA59AxGCoupLD6piVMKEXuYHco,10594
-nkululeko/model_bayes.py,sha256=C7MdZqsHVXGbL6pfTuLClOherhiWtxa61dtptEyDrxY,432
-nkululeko/model_cnn.py,sha256=vMGpNfsVYWddwAEjWtTwY9gPg1Ji_B_skvBFa4ZWe8U,5029
-nkululeko/model_gmm.py,sha256=2544Gwu-9swNJuJ7ah9-2ZUyXZvVqx_k2h8iDS6Ry4Q,603
-nkululeko/model_knn.py,sha256=2jNPK_GcA0bYxUfnDQ2ZapApvewS72j5-IOsu9sC3eo,544
-nkululeko/model_knn_reg.py,sha256=jF62r0M9lGx2tbvGHwoPGk4c8ex5j2hxKAT_1Kx3IBo,551
-nkululeko/model_mlp.py,sha256=QZomFOUKIuyg7aSBX23rNWWgthRuZ5c3yEBSilstCpw,7976
-nkululeko/model_mlp_regression.py,sha256=K_5_DSBiJqxuIBJMvhKAYkyEZN98w6X8co0RtZUBNYI,8750
-nkululeko/model_svm.py,sha256=eESHYUjIgNnx5hH4AgOXERImXA-eTjVaE2Fqkrlcjzk,522
-nkululeko/model_svr.py,sha256=hDF7TTNQOCp9uaA1d45bCnXZOrkyFC-IcVc4FLxkCbw,505
-nkululeko/model_tree.py,sha256=mskYf83CeaIUg6OdZINBVLtzWTJqMOB26wn-GRmG748,382
-nkululeko/model_tree_reg.py,sha256=0Eouaw7BHxdMMGPEBTr9-ZoU9CBU0unaPWgGH7glvvo,389
-nkululeko/model_xgb.py,sha256=Gd0piVg-7r4e3JNVhpLB6DcTibZGjIHo0ct1Ve6A97U,236
-nkululeko/model_xgr.py,sha256=rOJ3QZjTLIpxHh6GqyCo-ewG9IUL35Fd-0jRDNuM_bk,242
-nkululeko/modelrunner.py,sha256=IKvPcrvJS0voUfoFAyNAGlEhONZVb70ZEBH79hwWh_I,5380
-nkululeko/nkululeko.py,sha256=O2Zw7u-Mb7VP9MPxAlhdTkXV2lW2kETIuSJp7mfj_Tc,1671
-nkululeko/plots.py,sha256=rr4Fa0kckRNw5-mz9clikiB5ul8XJ9U4_1OebCUiNWw,10924
-nkululeko/predict.py,sha256=3ei4wn2by0p9Vkv7cllMcszmEjSM2vX0T6x_5rlgT28,1851
-nkululeko/randomsplicer.py,sha256=ZILsLHabKWbBB14l2UT9d0-b4lyuHkvvl9osHklbsoY,2674
-nkululeko/randomsplicing.py,sha256=MOLwxFTM0omsVBmKAN82PmGkD4zNnxwDYoWS4WQnuVU,1867
-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=xmkZrA3iEsro7vaBwWdey_pIleS1tYyjTFe-EfMUQHQ,4399
-nkululeko/syllable_nuclei.py,sha256=vK9dj5deqRnyEmlZmhFtKPzqKVGNCgTnWaG8UDITKNg,9913
-nkululeko/test.py,sha256=BbHGliDChAXqMe2oA579dJpyZSlPGAm5997lX_POboQ,1372
-nkululeko/test_predictor.py,sha256=7hbUhF09YqI7ixMp3gtVVnAO3prLF3J5tHH9mv125pM,2405
-nkululeko/util.py,sha256=gZrNTF4C7hKkEMCC_hoNkEAhAViWzWebP8LsHRew7s4,9731
-nkululeko-0.59.1.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.59.1.dist-info/METADATA,sha256=GczosYJcXJGLfEajloeb8Xm05z6K5-cSFOyqE0Prhmc,21494
-nkululeko-0.59.1.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-nkululeko-0.59.1.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.59.1.dist-info/RECORD,,