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

nkululeko/model.py

@@ -1,256 +0,0 @@
-# model.py
-from nkululeko.util import Util 
-import pandas as pd
-import numpy as np
-import nkululeko.glob_conf as glob_conf
-import sklearn.utils
-from nkululeko.reporter import Reporter
-import ast
-from sklearn.model_selection import GridSearchCV
-import pickle
-import random
-from sklearn.model_selection import LeaveOneGroupOut
-from sklearn.model_selection import StratifiedKFold
-
-
-class Model:
-    """Generic model class for linear (non-neural) algorithms"""
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        """Constructor taking the configuration and all dataframes"""
-        self.df_train, self.df_test, self.feats_train, self.feats_test = df_train, df_test, feats_train, feats_test
-        self.util = Util('model')
-        self.target = self.util.config_val('DATA', 'target', 'emotion')
-        self.run = 0
-        self.epoch = 0
-        self.logo = self.util.config_val('MODEL', 'logo', False)
-        self.xfoldx = self.util.config_val('MODEL', 'k_fold_cross', False)
-                
-    def set_testdata(self, data_df, feats_df):
-        self.df_test, self.feats_test = data_df, feats_df
-
-    def reset_test(self,  df_test, feats_test):
-        self.df_test, self.feats_test = df_test, feats_test
-
-
-    def set_id(self, run, epoch):
-        self.run = run
-        self.epoch = epoch
-        dir = self.util.get_path('model_dir')
-        name = f'{self.util.get_exp_name(only_train=True)}_{self.run}_{self.epoch:03d}.model'
-        self.store_path = dir+name
-
-
-    def _x_fold_cross(self):
-        # ignore train and test sets and do a x-fold-cross  evaluation
-        self.util.debug(f'ignoring splits and doing {self.xfoldx} fold cross validation')
-        feats = pd.concat([self.feats_train, self.feats_test])
-        annos = pd.concat([self.df_train, self.df_test])
-        targets = annos[self.target]
-        _skf = StratifiedKFold(n_splits=int(self.xfoldx))
-        truths, preds, results = [], [], []
-        g_index = 0
-        # leave-one-speaker loop    
-        for train_index, test_index in _skf.split(
-            feats, 
-            targets,
-        ):
-            train_x = feats.iloc[train_index].to_numpy()
-            train_y = targets[train_index]
-            self.clf.fit(train_x, train_y)
-            truth_x = feats.iloc[test_index].to_numpy()
-            truth_y = targets[test_index]
-            predict_y = self.clf.predict(truth_x)
-            report = Reporter(truth_y.astype(float), predict_y, self.run, self.epoch)
-            self.util.debug(f'result for fold {g_index}: {report.get_result().get_test_result()} ')
-            results.append(float(report.get_result().test))            
-            truths.append(truth_y)
-            preds.append(predict_y)
-            g_index += 1
-            
-        # combine speaker folds
-        truth = pd.concat(truths)
-        truth.name = 'truth'
-        pred = pd.Series(
-            np.concatenate(preds),
-            index=truth.index,
-            name='prediction',
-        )
-        self.truths = truth
-        self.preds = pred        
-        results = np.asarray(results)
-        self.util.debug(f'KFOLD: {self.xfoldx} folds: mean {results.mean():.3f}, std: {results.std():.3f}')
-    def _do_logo(self):
-        # ignore train and test sets and do a "leave one speaker group out"  evaluation
-        self.util.debug(f'ignoring splits and doing LOGO with {self.logo} groups')
-        logo = int(self.logo)
-        feats = pd.concat([self.feats_train, self.feats_test])
-        annos = pd.concat([self.df_train, self.df_test])
-        targets = annos[self.target]
-        _logo = LeaveOneGroupOut()        
-        truths, preds, results = [], [], []
-        # get unique list of speakers
-        speakers = annos['speaker'].unique()
-        # check for folds columns
-        if not 'fold' in annos.columns:
-            self.util.debug(f'creating random folds for {logo} groups') 
-            # create a random dictionary of groups
-            sdict = {}
-            # randomize the speaker order
-            random.shuffle(speakers)
-            folds = list(range(logo))
-            for i, s in enumerate(speakers):
-                sdict[s] = folds[i % len(folds)]    
-            # add this to the annotations  
-            annos['fold'] = annos['speaker'].apply(lambda x: str(sdict[x]))
-        else:
-            fold_count = annos['fold'].nunique()
-            self.util.debug(f'using existing folds for {fold_count} groups')  
-        g_index = 0
-        # leave-one-group loop    
-        for train_index, test_index in _logo.split(
-            feats, 
-            targets, 
-            groups=annos['fold'],
-        ):
-            train_x = feats.iloc[train_index].to_numpy()
-            train_y = targets[train_index]
-            self.clf.fit(train_x, train_y)
-            
-            truth_x = feats.iloc[test_index].to_numpy()
-            truth_y = targets[test_index]
-            predict_y = self.clf.predict(truth_x)
-            report = Reporter(truth_y.astype(float), predict_y, self.run, self.epoch)
-            result = report.get_result().get_test_result()
-            self.util.debug(f'result for speaker group {g_index}: {result} ')
-            results.append(float(report.get_result().test))
-            truths.append(truth_y)
-            preds.append(predict_y)
-            g_index += 1
-            
-        # combine speaker folds
-        truth = pd.concat(truths)
-        truth.name = 'truth'
-        pred = pd.Series(
-            np.concatenate(preds),
-            index=truth.index,
-            name='prediction',
-        )
-        self.truths = truth
-        self.preds = pred
-        results = np.asarray(results)
-        self.util.debug(f'LOGO: {self.logo} folds: mean {results.mean():.3f}, std: {results.std():.3f}')
-
-    def train(self):
-        """Train the model"""
-        # # 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
-
-        # then if leave one speaker group out validation is wanted
-        if self.logo:
-            self._do_logo()
-            return
-        # then if x fold cross validation is wanted
-        if self.xfoldx:
-            self._x_fold_cross()
-            return
-
-        # check for NANs in the features
-        # set up the data_loaders
-        if self.feats_train.isna().to_numpy().any():
-            self.util.debug(f'Model, train: replacing {self.feats_train.isna().sum().sum()} NANs with 0')
-            self.feats_train = self.feats_train.fillna(0)
-        # remove labels from features
-        feats = self.feats_train.to_numpy()
-        # compute class weights
-        if self.util.config_val('MODEL', 'class_weight', False):      
-            self.classes_weights = sklearn.utils.class_weight.compute_sample_weight(
-                class_weight='balanced',
-                y=self.df_train[self.target]
-            )
-
-        tuning_params = self.util.config_val('MODEL', 'tuning_params', False)
-        if tuning_params:
-            # tune the model meta parameters
-            tuning_params = ast.literal_eval(tuning_params)
-            tuned_params={}
-            try:
-                scoring = glob_conf.config['MODEL']['scoring']
-            except KeyError:
-                self.util.error('got tuning params but no scoring')
-            for param in tuning_params:
-                values = ast.literal_eval(glob_conf.config['MODEL'][param])
-                tuned_params[param] = values
-            self.util.debug(f'tuning on {tuned_params}')
-            self.clf = GridSearchCV(self.clf, tuned_params, refit = True, verbose = 3, scoring=scoring)
-            try: 
-                class_weight = self.util.config_val('MODEL', 'class_weight', False)
-                if class_weight:
-                    self.util.debug('using class weight')
-                    self.clf.fit(feats, self.df_train[self.target], sample_weight=self.classes_weights)
-                else:
-                    self.clf.fit(feats, self.df_train[self.target])    
-            except KeyError:
-                self.clf.fit(feats, self.df_train[self.target])
-            self.util.debug(f'winner parameters: {self.clf.best_params_}')
-        else:
-            class_weight = self.util.config_val('MODEL', 'class_weight', False)
-            if class_weight:
-                self.util.debug('using class weight')
-                self.clf.fit(feats, self.df_train[self.target], sample_weight=self.classes_weights)
-            else:
-                labels = self.df_train[self.target]
-                self.clf.fit(feats, labels)
-
-    def get_predictions(self):
-        predictions =  self.clf.predict(self.feats_test.to_numpy())
-        return predictions
-
-    def predict(self):
-        if self.feats_test.isna().to_numpy().any():
-            self.util.debug(f'Model, test: replacing {self.feats_test.isna().sum().sum()} NANs with 0')
-            self.feats_test = self.feats_test.fillna(0)
-        if self.logo or self.xfoldx:
-            report = Reporter(self.truths.astype(float), self.preds, self.run, self.epoch)
-            return report
-        """Predict the whole eval feature set"""
-        predictions = self.get_predictions()
-        report = Reporter(self.df_test[self.target]\
-            .to_numpy().astype(float), predictions, self.run, self.epoch)
-        return report
-
-    def predict_sample(self, features):
-        """Predict one sample"""
-        prediction = {}
-        if self.util.exp_is_classification():
-            # get the class probabilities
-            predictions = self.clf.predict_proba(features)
-            # pred = self.clf.predict(features)
-            for i in range(len(self.clf.classes_)):
-                cat = self.clf.classes_[i]
-                prediction[cat] = predictions[0][i]
-        else:
-            predictions = self.clf.predict(features)
-            prediction['result'] = predictions[0]
-        return prediction
-
-
-    def store(self):
-        with open(self.store_path, 'wb') as handle:
-            pickle.dump(self.clf, handle)
-
-        
-    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)}_{self.run}_{self.epoch:03d}.model'
-        with open(dir+name, 'rb') as handle:
-            self.clf = pickle.load(handle)
-
-    def load_path(self, path, run, epoch):
-        self.set_id(run, epoch)
-        with open(path, 'rb') as handle:
-            self.clf = pickle.load(handle)

nkululeko/model_bayes.py

@@ -1,14 +0,0 @@
-# model_bayes.py
-
-from sklearn.naive_bayes import GaussianNB
-from nkululeko.model import Model
-
-class Bayes_model(Model):
-    is_classifier = True
-
-    """An SVM model"""
-    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 = GaussianNB() # set up the classifier
-

nkululeko/model_cnn.py

@@ -1,118 +0,0 @@
-# cnnmodel.py
-
-from sklearn.utils import resample
-from nkululeko.model import Model
-import torch
-from sklearn.metrics import mean_squared_error
-import nkululeko.glob_conf as glob_conf
-from nkululeko.reporter import Reporter
-import numpy as np
-from loss_ccc import ConcordanceCorCoeff
-
-class CNN_model(Model):
-    """A CNN (convolutional neural net) model"""
-    is_classifier = True
-
-    def __init__(self, df_train, df_test, feats_train, feats_test):
-        """Constructor taking the configuration and all dataframes"""
-        Model.__init__(self, df_train, df_test, feats_train, feats_test)
-        self.util.debug(f'initializing model')
-        self.device = glob_conf.config['MODEL']['device']
-        pretrained_state = self.util.config_val('MODEL', 'pre_train', 'gender_state.pth.tar')
-        state = torch.load(pretrained_state)
-        state.pop('out.gender.weight')
-        state.pop('out.gender.bias')
-        state['fc1.weight'] = state.pop('fc1.gender.weight')
-        state['fc1.bias'] = state.pop('fc1.gender.bias')
-        model = audpann.Cnn10(sampling_rate=16000, output_dim=1)
-        model.load_state_dict(state, strict=False)
-        self.model = model.to(self.device)       
-        self.loss_func = self.util.config_val('MODEL', 'loss', 'mse')
-        if self.loss_func == 'mse':
-            self.criterion = torch.nn.MSELoss()
-        elif self.loss_func == '1-ccc':
-            self.criterion = ConcordanceCorCoeff()
-        else:
-            self.util.error(f'unknown loss function: {self.loss_func}')
-        self.util.debug(f'training model with {self.loss_func} loss function')
-        self.learning_rate = float(self.util.config_val('MODEL', 'learning_rate', 0.0001))
-        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learning_rate)
-
-    def train(self):
-        """Train the model one epoch"""
-        losses = []
-        # 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()
-
-        for features, labels in self.feats_train:
-            logits = self.model(features.to(self.device).float()).squeeze(1)
-            loss = self.criterion(logits, labels.float().to(self.device))
-            losses.append(loss.item())
-            self.optimizer.zero_grad()
-            loss.backward()
-            self.optimizer.step()
-        self.loss = (np.asarray(losses)).mean()
-
-    def predict(self):
-        """Predict the whole eval feature set"""
-        # evaluate on dev set
-        _, truths, predictions = self.evaluate_model(False)
-        # evaluate on train set, if there is one
-        result = 0
-        if self.feats_train != None:
-            result, _, _ = self.evaluate_model(True)
-        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 evaluate_model(self, on_train=False):
-        if on_train:
-            loader = self.feats_train
-        else:
-            loader = self.feats_test
-        logits = torch.zeros(len(loader.dataset))
-        targets = torch.zeros(len(loader.dataset))
-        self.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] =  self.model(features.to(self.device).float()).squeeze(1)
-                targets[start_index:end_index] = labels
-
-        measure = self.util.config_val('MODEL', 'measure', 'mse')
-        if measure == 'mse':
-            result = mean_squared_error(targets.numpy(), logits.numpy())
-        elif measure == 'ccc':
-            result = Reporter.ccc(targets.numpy(), logits.numpy())
-        else:
-            self.util.error(f'unknown measure: {measure}')
-        return result, targets, logits
-
-    def store(self):
-        torch.save(self.model.state_dict(), self.store_path)
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        # self.model.to(self.device)
-
-    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.device = self.util.config_val('MODEL', 'device', 'cpu')
-        self.store_path = dir+name
-        self.model = audpann.Cnn10(sampling_rate=16000, output_dim=1)
-        state_dict = torch.load(dir+name, map_location='cpu')
-        self.model.load_state_dict(state_dict, strict=False)
-        self.model.to(self.device)   

nkululeko/model_gmm.py

@@ -1,16 +0,0 @@
-# model_gmm.py
-
-from sklearn import mixture
-from nkululeko.model import Model
-
-class GMM_model(Model):
-    """An GMM 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)
-        n_components = int(self.util.config_val('MODEL', 'GMM_components', '4'))         
-        covariance_type = self.util.config_val('MODEL', 'GMM_covariance_type', 'full') 
-        self.clf = mixture.GaussianMixture(n_components=n_components, covariance_type=covariance_type)
-        # set up the classifier
-

nkululeko/model_knn.py

@@ -1,16 +0,0 @@
-# model_knn.py
-
-from sklearn.neighbors import KNeighborsClassifier
-from nkululeko.model import Model
-
-class KNN_model(Model):
-    """An KNN 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)
-        method = self.util.config_val('MODEL', 'KNN_weights', 'uniform') 
-        k = int(self.util.config_val('MODEL', 'K_val', '5'))
-        self.clf = KNeighborsClassifier(n_neighbors=k, weights=method) # set up the classifier
-

nkululeko/model_knn_reg.py

@@ -1,16 +0,0 @@
-# model_knn_reg.py
-
-from sklearn.neighbors import KNeighborsRegressor
-from nkululeko.model import Model
-
-class KNN_reg_model(Model):
-    """An KNN 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)
-        method = self.util.config_val('MODEL', 'KNN_weights', 'uniform') 
-        k = int(self.util.config_val('MODEL', 'K_val', '5'))
-        self.clf = KNeighborsRegressor(n_neighbors=k, weights=method) # set up the classifier
-

nkululeko/model_mlp.py

@@ -1,175 +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 recall_score
-from collections import OrderedDict
-from nkululeko.loss_softf1loss import SoftF1Loss
-
-class MLP_model(Model):
-    """MLP = multi layer perceptron"""
-
-    is_classifier = True
-
-    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', 'cross')
-        if criterion == 'cross':
-            self.criterion = torch.nn.CrossEntropyLoss()
-        elif criterion == 'f1':
-            self.criterion = SoftF1Loss(num_classes=self.class_num, weight=None, epsilon=1e-7)
-        else:
-            self.util.error(f'unknown loss function: {criterion}')
-        self.util.debug(f'using model with cross entropy 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)
-        # with dropout?
-        drop = self.util.config_val('MODEL', 'drop', False)
-        if drop:
-            self.util.debug(f'init: training with dropout: {drop}')
-        self.model = self.MLP(feats_train.shape[1], layers, self.class_num, 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))
-        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)
-        # set up the data_loaders
-        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 reset_test(self,  df_test, feats_test):
-        self.testloader = self.get_loader(feats_test, df_test, False)
-
-    def train(self):            
-        self.model.train()
-        losses = []
-        for features, labels in self.trainloader:
-            logits = self.model(features.to(self.device))
-            loss = self.criterion(logits, labels.to(self.device, dtype=torch.int64))
-            losses.append(loss.item())
-            self.optimizer.zero_grad()
-            loss.backward()
-            self.optimizer.step()
-        self.loss = (np.asarray(losses)).mean()
-
-    def predict(self):        
-        _, truths, predictions = self.evaluate_model(self.model, self.testloader, self.device)
-        uar, _, _ = self.evaluate_model(self.model, self.trainloader, self.device)
-        report = Reporter(truths, predictions, 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 = uar
-        return report
-
-    def get_predictions(self):
-        _, truths, predictions = self.evaluate_model(self.model, self.testloader, self.device)
-        return predictions.numpy()
-
-    def get_loader(self, df_x, df_y, shuffle):
-        data=[]
-        for i in range(len(df_x)):
-            data.append([df_x.values[i], df_y[self.target][i]])
-        return torch.utils.data.DataLoader(data, shuffle=shuffle, batch_size=self.batch_size)
-
-    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 evaluate_model(self, model, loader, device):
-        logits = torch.zeros(len(loader.dataset), self.class_num)
-        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))
-                targets[start_index:end_index] = labels
-
-        predictions = logits.argmax(dim=1)
-        uar = recall_score(targets.numpy(), predictions.numpy(), average='macro')
-        return uar, targets, predictions
-
-    def predict_sample(self, features):
-        """Predict one sample"""
-        with torch.no_grad():
-            logits = self.model(torch.from_numpy(features).to(self.device))
-        a = logits.numpy()
-        res = {}
-        for i in range(len(a[0])):
-            res[i] = a[0][i]
-        return res
-
-    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()}_{run}_{epoch:03d}.model'
-        name = f'{self.util.get_exp_name(only_train=True)}_{self.run}_{self.epoch:03d}.model'
-        self.device = self.util.config_val('MODEL', 'device', 'cpu')
-        layers = ast.literal_eval(glob_conf.config['MODEL']['layers'])
-        self.store_path = dir+name
-        drop = self.util.config_val('MODEL', 'drop', False)
-        if drop:
-            self.util.debug(f'loading: dropout set to: {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 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'dropout set to: {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()