nkululeko 0.95.0__py3-none-any.whl → 0.95.1__py3-none-any.whl

nkululeko/models/tests/test_model_mlp.py

@@ -0,0 +1,153 @@
+import numpy as np
+import pandas as pd
+import pytest
+import torch
+from unittest.mock import patch
+
+from nkululeko.models.model_mlp import MLPModel
+
+
+class DummyUtil:
+    def config_val(self, section, key, default=None):
+        # Provide defaults for required config values
+        if key == "manual_seed":
+            return True
+        if key == "loss":
+            return "cross"
+        if key == "device":
+            return "cpu"
+        if key == "learning_rate":
+            return 0.001
+        if key == "batch_size":
+            return 2
+        if key == "drop":
+            return False
+        return default
+    def debug(self, msg): pass
+    def error(self, msg): raise Exception(msg)
+    def get_path(self, key): return "./"
+    def get_exp_name(self, only_train=False): return "exp"
+
+@pytest.fixture(autouse=True)
+def patch_globals(monkeypatch):
+    # Patch global config and labels
+    import nkululeko.glob_conf as glob_conf
+    glob_conf.config = {
+        "DATA": {"target": "label"},
+        "MODEL": {"layers": "{'a': 8, 'b': 4}"}
+    }
+    glob_conf.labels = [0, 1]
+    yield
+
+@pytest.fixture
+def dummy_data():
+    # 4 samples, 3 features
+    feats_train = pd.DataFrame(np.random.rand(4, 3), columns=['f1', 'f2', 'f3'])
+    feats_test = pd.DataFrame(np.random.rand(2, 3), columns=['f1', 'f2', 'f3'])
+    df_train = pd.DataFrame({'label': [0, 1, 0, 1]})
+    df_test = pd.DataFrame({'label': [1, 0]})
+    return df_train, df_test, feats_train, feats_test
+
+@pytest.fixture
+def mlp_model(dummy_data, monkeypatch):
+    df_train, df_test, feats_train, feats_test = dummy_data
+    with patch.object(MLPModel, "__init__", return_value=None):
+        model = MLPModel(df_train, df_test, feats_train, feats_test)
+        model.util = DummyUtil()
+        model.n_jobs = 1
+        model.target = "label"
+        model.class_num = 2
+        model.criterion = torch.nn.CrossEntropyLoss()
+        model.device = "cpu"
+        model.learning_rate = 0.001
+        model.batch_size = 2
+        model.num_workers = 1
+        model.loss = 0.0
+        model.loss_eval = 0.0
+        model.run = 0
+        model.epoch = 0
+        model.df_test = df_test
+        model.feats_test = feats_test
+        model.feats_train = feats_train
+        
+        # Create a simple MLP model for testing
+        model.model = MLPModel.MLP(3, {'a': 8, 'b': 4}, 2, False).to("cpu")
+        model.optimizer = torch.optim.Adam(model.model.parameters(), lr=0.001)
+        
+        # Create data loaders
+        model.trainloader = model.get_loader(feats_train, df_train, True)
+        model.testloader = model.get_loader(feats_test, df_test, False)
+        model.store_path = "/tmp/test_model.pt"
+        
+        return model
+
+def test_mlpmodel_init(mlp_model):
+    assert hasattr(mlp_model, "model")
+    assert hasattr(mlp_model, "trainloader")
+    assert hasattr(mlp_model, "testloader")
+    assert mlp_model.model is not None
+
+def test_train_and_predict(mlp_model):
+    mlp_model.train()
+    report = mlp_model.predict()
+    assert hasattr(report, "result")
+    assert hasattr(report.result, "train")
+
+def test_get_predictions(mlp_model):
+    mlp_model.train()
+    preds = mlp_model.get_predictions()
+    assert isinstance(preds, np.ndarray)
+    assert preds.shape[0] == 2
+
+def test_get_probas(mlp_model):
+    mlp_model.train()
+    _, _, _, logits = mlp_model.evaluate(mlp_model.model, mlp_model.testloader, mlp_model.device)
+    probas = mlp_model.get_probas(logits)
+    assert isinstance(probas, pd.DataFrame)
+    assert set(probas.columns) == set([0, 1])
+
+def test_predict_sample(mlp_model):
+    mlp_model.train()
+    feats = np.random.rand(3)
+    res = mlp_model.predict_sample(feats)
+    assert isinstance(res, dict)
+    assert set(res.keys()) == set([0, 1])
+
+def test_predict_shap(mlp_model):
+    mlp_model.train()
+    feats = pd.DataFrame(np.random.rand(2, 3))
+    results = mlp_model.predict_shap(feats)
+    assert len(results) == 2
+
+def test_store_and_load(tmp_path, mlp_model, monkeypatch):
+    mlp_model.train()
+    
+    # Mock the util methods that load() uses to construct the path
+    def mock_get_path(key):
+        if key == "model_dir":
+            return str(tmp_path) + "/"
+        return "./"
+    
+    def mock_get_exp_name(only_train=False):
+        return "model"
+        
+    mlp_model.util.get_path = mock_get_path
+    mlp_model.util.get_exp_name = mock_get_exp_name
+    
+    # Set store path to match what load() will construct
+    mlp_model.store_path = str(tmp_path) + "/model_0_000.model"
+    mlp_model.store()
+    
+    # Simulate loading
+    mlp_model.load(0, 0)
+    assert mlp_model.model is not None
+
+def test_set_testdata(mlp_model, dummy_data):
+    _, df_test, _, feats_test = dummy_data
+    mlp_model.set_testdata(df_test, feats_test)
+    assert mlp_model.testloader is not None
+
+def test_reset_test(mlp_model, dummy_data):
+    _, df_test, _, feats_test = dummy_data
+    mlp_model.reset_test(df_test, feats_test)
+    assert mlp_model.testloader is not None

nkululeko/models/tests/test_model_xgb.py

@@ -0,0 +1,33 @@
+import pandas as pd
+import pytest
+
+from ..model_xgb import XGB_model
+
+
+class DummyUtil:
+    def config_val(self, section, key, default):
+        return default
+    def debug(self, msg):
+        pass
+
+class DummyModel(XGB_model):
+    def __init__(self, df_train, df_test, feats_train, feats_test):
+        # Patch util before calling super().__init__
+        self.util = DummyUtil()
+        self.target = "label"
+        super().__init__(df_train, df_test, feats_train, feats_test)
+        self.util = DummyUtil()
+        self.target = "label"
+
+@pytest.fixture
+def dummy_data():
+    df_train = pd.DataFrame({"label": [0, 1], "f1": [1.0, 2.0]})
+    df_test = pd.DataFrame({"label": [0, 1], "f1": [1.5, 2.5]})
+    feats_train = df_train[["f1"]]
+    feats_test = df_test[["f1"]]
+    return df_train, df_test, feats_train, feats_test
+
+def test_get_type_returns_xgb(dummy_data):
+    df_train, df_test, feats_train, feats_test = dummy_data
+    model = DummyModel(df_train, df_test, feats_train, feats_test)
+    assert model.get_type() == "xgb"

nkululeko/predict.py

@@ -62,8 +62,9 @@ def main():
         df = df.rename(columns={"class_label": target})
     sample_selection = util.config_val("PREDICT", "sample_selection", "all")
     name = f"{sample_selection}_predicted"
-    df.to_csv(f"{expr.data_dir}/{name}.csv")
-    util.debug(f"saved {os.path.join(expr.data_dir, name)}.csv")
+    res_dir = util.get_res_dir()
+    df.to_csv(os.path.join(res_dir, f"{name}.csv"))
+    util.debug(f"saved {os.path.join(res_dir, name)}.csv")
     print("DONE")
 
 

nkululeko/reporting/reporter.py

@@ -2,6 +2,7 @@ import ast
 import glob
 import json
 import math
+import os
 
 # import os
 from confidence_intervals import evaluate_with_conf_int
@@ -173,6 +174,17 @@ class Reporter:
             probas["correct"] = probas.predicted == probas.truth
             if file_name is None:
                 file_name = self.util.get_pred_name() + ".csv"
+            else:
+                # Ensure the file_name goes to the results directory
+                if not os.path.isabs(file_name):
+                    res_dir = self.util.get_res_dir()
+                    if not file_name.endswith(".csv"):
+                        file_name = os.path.join(res_dir, file_name + ".csv")
+                    else:
+                        file_name = os.path.join(res_dir, file_name)
+                else:
+                    if not file_name.endswith(".csv"):
+                        file_name = file_name + ".csv"
             self.probas = probas
             probas.to_csv(file_name)
             self.util.debug(f"Saved probabilities to {file_name}")

nkululeko/test_predictor.py

@@ -5,6 +5,7 @@ Predict targets from a model and save as csv file.
 """
 
 import ast
+import os
 
 import pandas as pd
 from sklearn.preprocessing import LabelEncoder
@@ -24,7 +25,12 @@ class TestPredictor:
         self.label_encoder = labenc
         self.target = glob_conf.config["DATA"]["target"]
         self.util = Util("test_predictor")
-        self.name = name
+        # Construct full path to results directory
+        res_dir = self.util.get_res_dir()
+        if os.path.isabs(name):
+            self.name = name
+        else:
+            self.name = os.path.join(res_dir, name)
 
     def predict_and_store(self):
         label_data = self.util.config_val("DATA", "label_data", False)

nkululeko/tests/__init__.py

@@ -0,0 +1 @@
+# Tests package for nkululeko

nkululeko/tests/test_balancing.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Simple and comprehensive test suite for all balancing methods in DataBalancer.
+
+Tests all 11 balancing methods from balance.py:
+
+Oversampling (5): ros, smote, adasyn, borderlinesmote, svmsmote
+Undersampling (4): clustercentroids, randomundersampler, editednearestneighbours, tomeklinks  
+Combination (2): smoteenn, smotetomek
+
+Run with: pytest nkululeko/tests/test_balancing.py -v
+"""
+
+import numpy as np
+import pandas as pd
+import pytest
+from nkululeko.balance import DataBalancer
+import nkululeko.glob_conf as glob_conf
+
+
+@pytest.fixture
+def sample_data():
+    """Create sample imbalanced data that works with all methods"""
+    np.random.seed(42)
+    
+    # Majority class: 100 samples, Minority class: 25 samples
+    # Well-separated for better algorithm performance
+    majority_features = np.random.randn(100, 10) 
+    minority_features = np.random.randn(25, 10) + 3  # Good separation
+    
+    features = np.vstack([majority_features, minority_features])
+    labels = np.array([0] * 100 + [1] * 25)
+    
+    df_train = pd.DataFrame({'target': labels})
+    feats_train = features
+    
+    return df_train, feats_train
+
+
+@pytest.fixture
+def mock_config():
+    """Mock configuration for testing"""
+    original_config = getattr(glob_conf, 'config', None)
+    
+    glob_conf.config = {
+        'FEATS': {'balancing': 'smote'},
+        'DATA': {'target': 'target'},
+        'MODEL': {'type': 'mlp'}
+    }
+    
+    yield glob_conf.config
+    
+    if original_config is not None:
+        glob_conf.config = original_config
+
+
+class TestDataBalancer:
+    """Simple test suite for DataBalancer - tests all 11 methods"""
+    
+    def test_initialization(self):
+        """Test 1: DataBalancer can be initialized"""
+        balancer = DataBalancer(random_state=42)
+        assert balancer is not None
+        assert balancer.random_state == 42
+    
+    def test_get_all_supported_methods(self):
+        """Test 2: All 11 methods are reported as supported"""
+        balancer = DataBalancer()
+        methods = balancer.get_supported_methods()
+        
+        # Check we have all 3 categories
+        assert 'oversampling' in methods
+        assert 'undersampling' in methods  
+        assert 'combination' in methods
+        
+        # Check exact counts
+        assert len(methods['oversampling']) == 5
+        assert len(methods['undersampling']) == 4
+        assert len(methods['combination']) == 2
+        
+        # Total should be 11
+        total = (len(methods['oversampling']) + 
+                len(methods['undersampling']) + 
+                len(methods['combination']))
+        assert total == 11
+    
+    def test_method_validation(self):
+        """Test 3: Method validation works correctly"""
+        balancer = DataBalancer()
+        
+        # Valid methods
+        assert balancer.is_valid_method('ros') == True
+        assert balancer.is_valid_method('smote') == True
+        assert balancer.is_valid_method('clustercentroids') == True
+        assert balancer.is_valid_method('smoteenn') == True
+        
+        # Invalid methods
+        assert balancer.is_valid_method('invalid') == False
+        assert balancer.is_valid_method('') == False
+    
+    def test_all_oversampling_methods(self, sample_data, mock_config):
+        """Test 4: All 5 oversampling methods work"""
+        df_train, feats_train = sample_data
+        balancer = DataBalancer(random_state=42)
+        
+        oversampling_methods = ['ros', 'smote', 'adasyn', 'borderlinesmote', 'svmsmote']
+        
+        for method in oversampling_methods:
+            print(f"Testing oversampling: {method}")
+            
+            balanced_df, balanced_features = balancer.balance_features(
+                df_train=df_train,
+                feats_train=feats_train,
+                target_column='target',
+                method=method
+            )
+            
+            # Basic checks
+            assert len(balanced_df) >= len(df_train), f"{method} should increase/maintain size"
+            assert len(balanced_df) == len(balanced_features), f"{method} length mismatch"
+            assert balanced_features.shape[1] == feats_train.shape[1], f"{method} feature dim changed"
+            
+            print(f"✓ {method} passed")
+    
+    def test_all_undersampling_methods(self, sample_data, mock_config):
+        """Test 5: All 4 undersampling methods work"""
+        df_train, feats_train = sample_data
+        balancer = DataBalancer(random_state=42)
+        
+        undersampling_methods = ['clustercentroids', 'randomundersampler', 
+                               'editednearestneighbours', 'tomeklinks']
+        
+        for method in undersampling_methods:
+            print(f"Testing undersampling: {method}")
+            
+            balanced_df, balanced_features = balancer.balance_features(
+                df_train=df_train,
+                feats_train=feats_train,
+                target_column='target',
+                method=method
+            )
+            
+            # Basic checks
+            assert len(balanced_df) <= len(df_train), f"{method} should decrease/maintain size"
+            assert len(balanced_df) == len(balanced_features), f"{method} length mismatch"
+            assert balanced_features.shape[1] == feats_train.shape[1], f"{method} feature dim changed"
+            
+            print(f"✓ {method} passed")
+    
+    def test_all_combination_methods(self, sample_data, mock_config):
+        """Test 6: All 2 combination methods work"""
+        df_train, feats_train = sample_data
+        balancer = DataBalancer(random_state=42)
+        
+        combination_methods = ['smoteenn', 'smotetomek']
+        
+        for method in combination_methods:
+            print(f"Testing combination: {method}")
+            
+            balanced_df, balanced_features = balancer.balance_features(
+                df_train=df_train,
+                feats_train=feats_train,
+                target_column='target',
+                method=method
+            )
+            
+            # Basic checks
+            assert len(balanced_df) == len(balanced_features), f"{method} length mismatch"
+            assert balanced_features.shape[1] == feats_train.shape[1], f"{method} feature dim changed"
+            assert len(balanced_df) > 0, f"{method} resulted in empty dataset"
+            
+            print(f"✓ {method} passed")
+    
+    def test_all_11_methods_comprehensive(self, sample_data, mock_config):
+        """Test 7: All 11 methods work in one comprehensive test"""
+        df_train, feats_train = sample_data
+        balancer = DataBalancer(random_state=42)
+        
+        # Get all methods from the balancer itself
+        all_methods = balancer.get_supported_methods()
+        
+        successful_methods = []
+        failed_methods = []
+        
+        print("Testing all 11 balancing methods...")
+        
+        for category, methods in all_methods.items():
+            for method in methods:
+                try:
+                    balanced_df, balanced_features = balancer.balance_features(
+                        df_train=df_train,
+                        feats_train=feats_train,
+                        target_column='target',
+                        method=method
+                    )
+                    
+                    # Verify results
+                    assert len(balanced_df) == len(balanced_features)
+                    assert balanced_features.shape[1] == feats_train.shape[1]
+                    assert len(balanced_df) > 0
+                    
+                    successful_methods.append(method)
+                    print(f"✓ {method} succeeded")
+                    
+                except Exception as e:
+                    failed_methods.append((method, str(e)))
+                    print(f"✗ {method} failed: {str(e)}")
+        
+        print(f"\nResults: {len(successful_methods)}/11 methods successful")
+        print(f"Successful: {successful_methods}")
+        if failed_methods:
+            print(f"Failed: {[m[0] for m in failed_methods]}")
+        
+        # All 11 methods should work
+        assert len(successful_methods) == 11, f"Expected 11 successful methods, got {len(successful_methods)}"
+        assert len(failed_methods) == 0, f"Some methods failed: {failed_methods}"
+    
+    def test_invalid_method_handling(self, sample_data, mock_config):
+        """Test 8: Invalid methods are handled correctly"""
+        df_train, feats_train = sample_data
+        balancer = DataBalancer(random_state=42)
+        
+        # Test that invalid methods are detected by validation
+        assert balancer.is_valid_method('invalid_method') == False
+        assert balancer.is_valid_method('nonexistent') == False
+        assert balancer.is_valid_method('') == False
+        
+        # Note: The actual balance_features() with invalid method calls sys.exit()
+        # This is expected behavior in the current implementation
+        print("✓ Invalid method validation works correctly")
+
+
+def test_simple_integration():
+    """Test 9: Simple integration test without fixtures"""
+    print("Simple integration test...")
+    
+    # Create simple data
+    np.random.seed(42)
+    features = np.random.randn(60, 5)
+    labels = np.array([0] * 40 + [1] * 20)  # 40 vs 20 imbalance
+    
+    df_train = pd.DataFrame({'target': labels})
+    
+    # Test a few key methods
+    balancer = DataBalancer(random_state=42)
+    key_methods = ['ros', 'smote', 'clustercentroids', 'randomundersampler']
+    
+    for method in key_methods:
+        balanced_df, balanced_features = balancer.balance_features(
+            df_train=df_train,
+            feats_train=features,
+            target_column='target',
+            method=method
+        )
+        
+        assert len(balanced_df) == len(balanced_features)
+        print(f"✓ {method} integration test passed")
+    
+    print("✓ Integration test completed")
+
+
+if __name__ == "__main__":
+    print("Running simple balancing tests...")
+    print("=" * 50)
+    
+    # Run integration test
+    test_simple_integration()
+    
+    print("=" * 50)
+    print("Direct test completed! Run 'pytest test_balancing.py -v' for full tests")

nkululeko/utils/util.py

@@ -106,15 +106,15 @@ class Util:
             except KeyError:
                 # some default values
                 if entry == "fig_dir":
-                    entryn = "./images/"
+                    entryn = "images/"
                 elif entry == "res_dir":
-                    entryn = "./results/"
+                    entryn = "results/"
                 elif entry == "model_dir":
-                    entryn = "./models/"
+                    entryn = "models/"
                 elif entry == "cache":
-                    entryn = "./cache/"
+                    entryn = "cache/"
                 else:
-                    entryn = "./store/"
+                    entryn = "store/"
 
             # Expand image, model and result directories with run index
             if entry == "fig_dir" or entry == "res_dir" or entry == "model_dir":

{nkululeko-0.95.0.dist-info → nkululeko-0.95.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nkululeko
-Version: 0.95.0
+Version: 0.95.1
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt

{nkululeko-0.95.0.dist-info → nkululeko-0.95.1.dist-info}/RECORD

@@ -2,8 +2,9 @@ examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
 nkululeko/aug_train.py,sha256=wpiHCJ7zsW38kumg3ypwXZe2HQrhUblAnv7P2QeJnAc,3525
 nkululeko/augment.py,sha256=3RzaxB3gRxovgJVjHXi0glprW01J7RaHhUkqotW2T3U,2955
+nkululeko/balance.py,sha256=r7opXbrqAipm2euPPaOmLlA5J10p2bHQgO5kWk2x9ro,8702
 nkululeko/cacheddataset.py,sha256=XFpWZmbJRg0pvhnIgYf0TkclxllD-Fctu-Ol0PF_00c,969
-nkululeko/constants.py,sha256=kSkvbiOI3g6sa27nNrD9sHxZMswo_qr0qKYSc_hZQLY,39
+nkululeko/constants.py,sha256=9E1ltDzIxGnwuxdRBW6OUWwJB8Im9_c4dnOUwjcDDr8,39
 nkululeko/demo-ft.py,sha256=iD9Pzp9QjyAv31q1cDZ75vPez7Ve8A4Cfukv5yfZdrQ,770
 nkululeko/demo.py,sha256=tu7Al2l5MCLVegkDC-NE2wcuc_YE7NRbgOlPW3yhGEs,4940
 nkululeko/demo_feats.py,sha256=BvZjeNFTlERIRlq34OHM4Z96jdDQAhB01BGQAUcX9dM,2026
@@ -17,19 +18,19 @@ nkululeko/file_checker.py,sha256=xJY0Q6w47pnmgJVK5rcAKPYBrCpV7eBT4_3YBzTx-H8,345
 nkululeko/filter_data.py,sha256=4sGrKvMZ_hLnJPrHm_CqjDPKIRV8REWoT7nfSYGXbwo,7305
 nkululeko/fixedsegment.py,sha256=Tb92QiuiyMsOO3WRWwuGjZGibS8hbHHCrcWAXGk7g04,2868
 nkululeko/glob_conf.py,sha256=NLFh-1_I0Wdfo2EnSq1Oppx23AX6jAUpgFbk2zqZJ24,659
-nkululeko/modelrunner.py,sha256=mnM5JBTiTVH4BOGZBepOuwEzAgrZDmoejhpVEvzq35s,11970
+nkululeko/modelrunner.py,sha256=OFN18uG84iJyjNVWjcvDpqbcBrmylziXCakUTNE2-ZQ,10530
 nkululeko/multidb.py,sha256=sO6OwJn8sn1-C-ig3thsIL8QMWHdV9SnJhDodKjeKrI,6876
 nkululeko/nkuluflag.py,sha256=PGWSmZz-PiiHLgcZJAoGOI_Y-sZDVI1ksB8p5r7riWM,3725
 nkululeko/nkululeko.py,sha256=6ALPMMIz6l0O3IRaP0q4b59ZUxpfzNqLQUqZMf5t3Zo,1976
 nkululeko/plots.py,sha256=lUxgyoriYTwdpHZvBBQ4e41v77deQrt0PcRDLJWijys,27503
-nkululeko/predict.py,sha256=VSF42CqJvyiwAnvoThV0oNNJLHhTRMS0cI6lICQeptc,2177
+nkululeko/predict.py,sha256=PWv1Pc39lrxqqIWrYszVk5SL37dDL93CHgcruItNID8,2211
 nkululeko/resample.py,sha256=rn3-M1A-iwVGibfQNGyeYNa7briD24lIN9Szq_1uTJo,5194
 nkululeko/runmanager.py,sha256=YtGQP0UyyQTKkilncB1XYM-T8oatzGcZEOcj5SorjJw,8902
 nkululeko/scaler.py,sha256=a4lKwWT436TV4VEvqtP1uQ58Yz67XVHr1HjO5gp3xLI,5109
 nkululeko/segment.py,sha256=7UrJEwdLmh9wDL5iBwpdJyJm9dwSxidHrHt-_D2qtxw,4949
 nkululeko/syllable_nuclei.py,sha256=5w_naKxNxz66a_qLkraemi2fggM-gWesiiBPS47iFcE,9931
 nkululeko/test.py,sha256=1w624vo5KTzmFC8BUStGlLDmIEAFuJUz7J0W-gp7AxI,1677
-nkululeko/test_predictor.py,sha256=RPQxorj1uygLeSnAuNims5CFccXwrDwTnrIDs-gDlNQ,2859
+nkululeko/test_predictor.py,sha256=i8vSaB8OOrdELoDttQVMs2Bc-fUOi2C5ANqnt32K3Zk,3064
 nkululeko/test_pretrain.py,sha256=6FZeETlWzg9Cq_sn3BFKhfH91jW26nAIDm1bJkInNNA,8463
 nkululeko/augmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/augmenting/augmenter.py,sha256=TUUznEz0pe9DSMC9r7LoBckuvsJTprvypeV5-8zLn20,2846
@@ -52,6 +53,8 @@ nkululeko/autopredict/ap_text.py,sha256=zaz9qIg90-ghZhBe1ka0HoUnap6s6RyopUKoCptt
 nkululeko/autopredict/ap_valence.py,sha256=9S06SpO_zXKSpkf0InHYYXZcD9HDGoCJ6UPkn__eBAg,1027
 nkululeko/autopredict/estimate_snr.py,sha256=1k9-XadABudnsNOeFZD_Fg0E64-GUQVS7JEp82MLQS4,4995
 nkululeko/autopredict/whisper_transcriber.py,sha256=DWDvpRaV5KmUF18ojPEvxnVXm_h_nWyY-TfW2Ngd5N8,2941
+nkululeko/autopredict/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nkululeko/autopredict/tests/test_whisper_transcriber.py,sha256=ilas6j3OUvq_xnQCRZgytQCtyrpNU6tvG5a8kPvVKBQ,5085
 nkululeko/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/data/dataset.py,sha256=JLbBYGniUrjwxs-HtbIyhqO3Cv-ELfpmlq7jzij4dBc,41759
 nkululeko/data/dataset_csv.py,sha256=AIbtB6pGk5BSQGIgfokZ7tEGFjmuOq5w2XumRSimVWs,4833
@@ -68,10 +71,10 @@ nkululeko/feat_extract/feats_hubert.py,sha256=F3vrPCkx8EimJjFWYCZ7Yg9uo1G3NjYt4U
 nkululeko/feat_extract/feats_import.py,sha256=cPi4XRuRs71npB8YGXr7rYOvkeTU_oZEl3GrGncdiqY,2222
 nkululeko/feat_extract/feats_mld.py,sha256=5aRoYiGDm5ApoFntxAMQYPjEelXHHRBHZcAJR9dxaeI,1945
 nkululeko/feat_extract/feats_mos.py,sha256=vkH1FdXtduoU0-yjBtVccC2b_p_eyH8laRnwlL7QTVM,4136
-nkululeko/feat_extract/feats_opensmile copy.py,sha256=BLj5sUaBPz7vLPfNlt9LdQurSypmViqgSpPK-6aXGhQ,4029
 nkululeko/feat_extract/feats_opensmile.py,sha256=HwbGs0EaPxZ7DznQZFem8RYgyQWz02oya77uVY7KhZE,9203
 nkululeko/feat_extract/feats_oxbow.py,sha256=TRoEJx5EKZiqoPoPRibHc0vkBMoZcKlGoGNq4NbyHZw,4895
-nkululeko/feat_extract/feats_praat.py,sha256=jZ-XXbP3iy25QQIzA4Hrv0HxsYvJNPavoCW2FyJNKMg,3064
+nkululeko/feat_extract/feats_praat.py,sha256=3j1xySKqW74USjk8DweWAajHeTcuszKCFY1htQhe1cY,3070
+nkululeko/feat_extract/feats_praat_core.py,sha256=Q0OVuo5h38a860yflzRtUpy0J0w7WCg0aBLrDhIskFc,28524
 nkululeko/feat_extract/feats_snr.py,sha256=Zxwo78HLleNsziYLOj34RQUnp9I7r1yMXqjYipDOjZw,2761
 nkululeko/feat_extract/feats_spectra.py,sha256=6WhFUpB0WTutg7OFMlAw9lSwVU5OBYCDcPRxaiH-Qn8,3621
 nkululeko/feat_extract/feats_spkrec.py,sha256=o_6bdU4lIkj64S5Kdjf1iyuo1VASeYxE4XdxV94a8gE,4732
@@ -81,8 +84,10 @@ nkululeko/feat_extract/feats_wav2vec2.py,sha256=q1QzMD3KbhF2SOmxdwI7CiViRmhlFRyg
 nkululeko/feat_extract/feats_wavlm.py,sha256=O9cfc39VF5aPJRRATKb37pHT4W11i2cu5O1mY9LOjIA,4755
 nkululeko/feat_extract/feats_whisper.py,sha256=n3ESZtva7wshs8E8diBlQYa9xCH_P0UY1DncSrxz-FY,4508
 nkululeko/feat_extract/featureset.py,sha256=clcBv9rzBRW-bfw7JC_FYTjU5uUS-c0UE1XtQLYYRiE,1615
-nkululeko/feat_extract/feinberg_praat.py,sha256=mMin5V-Kmx24oYJT_miNFN4t-tEVEF3Cd0969xiVV0E,28573
 nkululeko/feat_extract/transformer_feature_extractor.py,sha256=LaXuW-AJZ931ttLis0J5h9N3RtiiE51BnkxJR-bubfY,5837
+nkululeko/feat_extract/tests/__init__.py,sha256=pzjkYs1PNo7107jIXKa_xwdBR2SKxzkg53a9W3bvbpw,32
+nkululeko/feat_extract/tests/test_feats_opensmile.py,sha256=eYjGBsH6UkuRleKzGZHNv2cXRZz2xPCw0dkTfXw5S9s,5761
+nkululeko/feat_extract/tests/test_feats_praat_core.py,sha256=ntbpIrehr4D-lOvaE0hNCe-og5sN4syBGBUTuNGZpDo,20916
 nkululeko/losses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/losses/loss_ccc.py,sha256=NOK0y0fxKUnU161B5geap6Fmn8QzoPl2MqtPiV8IuJE,976
 nkululeko/losses/loss_softf1loss.py,sha256=5gW-PuiqeAZcRgfwjueIOQtMokOjZWgQnVIv59HKTCo,1309
@@ -104,26 +109,31 @@ nkululeko/models/model_tuned.py,sha256=74c_pQUtpx_x8bM3r5ufuqhaaQxfy6KRUqirdzSac
 nkululeko/models/model_xgb.py,sha256=_VxFFP1QcoyxrwvJSrzdIwwDt85IulUWvg1BxXBgN1Y,6616
 nkululeko/models/model_xgr.py,sha256=H01FJCRgmX2unvambMs5TTCS9sI6VDB9ip9G6rVGt2c,419
 nkululeko/models/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nkululeko/models/tests/test_model_knn.py,sha256=hFCJ0C0taQO-fwA7j8HcFrwCSluSb6Vg4NCQQ_zL4bc,1793
+nkululeko/models/tests/test_model_mlp.py,sha256=XVvniKAtroxLRKyYGW-ew1mHuRo3_cWk4nGnXQ5aDEk,4977
 nkululeko/models/tests/test_model_svm.py,sha256=spDlZmeBKBdK4EFBpOgEkaAfGeGH9kau6CqSWOY6Uag,1856
+nkululeko/models/tests/test_model_xgb.py,sha256=-Rz5YTeqUJ4Kwdh5ny31c3zxsUJXTypR4L3ItoOU7yU,1036
 nkululeko/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/reporting/defines.py,sha256=0vh-Tlx4fAPpk1o6mP_4x3EkIoqzYMr38IZnj-JM5z4,641
 nkululeko/reporting/latex_writer.py,sha256=NGwSIfd4nfslDkNUOSZSdqY_VDLA8634thyhe-vj1bY,1824
 nkululeko/reporting/report.py,sha256=B5eoIKMz46VKDBsi7M9u_iegzAD-E3eGCmolzSFjZ3c,1118
 nkululeko/reporting/report_item.py,sha256=drkknsyFhGviaPJNmPQtCXJmRhTSSfjNcJt0Bls6JAA,533
-nkululeko/reporting/reporter.py,sha256=bfRMN-8nAHAx3iWvjumQsqS-7DHdv7fgAzaUkdi-_qo,20336
+nkululeko/reporting/reporter.py,sha256=e-piNtnv0QUWKs9Ha_d4CzgqJxPBG9XBm3Ru8y0ot-U,20896
 nkululeko/reporting/result.py,sha256=G63a2tHCwHhM6NBJgYzsWKWJm4Yu3r4hsCHA2Km7eHU,1073
 nkululeko/segmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/segmenting/seg_inaspeechsegmenter.py,sha256=b3t0zdpJYofKWMyKRMtMMX91xeR-k8d5pbnNaQHcsOE,1902
 nkululeko/segmenting/seg_pyannote.py,sha256=6IPbgjnGOz9juzEKDTZN3PSipX4t6Mz-DILAx3rp5do,4216
 nkululeko/segmenting/seg_silero.py,sha256=ulodnvtRq5MLHDxy_RmAK4tJg6h1d-mPq-uCPFkGVKg,4258
+nkululeko/tests/__init__.py,sha256=XzD6C-ZuewsccUwx7KzEUtUxJrRx2d7sPFViscjf1O0,30
+nkululeko/tests/test_balancing.py,sha256=21110R77iTcSWKiSTxYDkJ26lxPFTlZf_ZwVjeiSh4w,10164
 nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=SrrYaU7AB80MZHiV1jcB0h_zigvYLYgSVNTXV4ao38g,4593
 nkululeko/utils/stats.py,sha256=3Fyx8q8BSKYmiufT6OkRug9RATWmGrr9BaX_y8jziWo,3074
 nkululeko/utils/unzip.py,sha256=G68f5120TjwACZC3bQcneMniddnwubPbBdMc2L5KBOo,1206
-nkululeko/utils/util.py,sha256=b4wolRb-9eCgfUDaxedcG3ys6HwgJrO5uoYvGSvi1nc,18571
-nkululeko-0.95.0.dist-info/licenses/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.95.0.dist-info/METADATA,sha256=wVnk9XYBqWK3W55yNDp7-AK8h4Xpqgd1sRuWBrDGvV8,2874
-nkululeko-0.95.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nkululeko-0.95.0.dist-info/entry_points.txt,sha256=lNTkFEdh6Kjo5o95ZAWf_0Lq-4ztGoAoMVSDuPtuyS0,442
-nkululeko-0.95.0.dist-info/top_level.txt,sha256=bf1k1YKkqcXemNX_cUgoyKqQ3_GVErPqAY-53J36jkM,19
-nkululeko-0.95.0.dist-info/RECORD,,
+nkululeko/utils/util.py,sha256=o62TZRcxO1VflINai6ojEzSmcbXIFInNLGogSbqJgiA,18561
+nkululeko-0.95.1.dist-info/licenses/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.95.1.dist-info/METADATA,sha256=KhJ1JPenNsZGUIhdeYGvNKrM1H-ioqONAh06LpxdnMQ,2874
+nkululeko-0.95.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nkululeko-0.95.1.dist-info/entry_points.txt,sha256=lNTkFEdh6Kjo5o95ZAWf_0Lq-4ztGoAoMVSDuPtuyS0,442
+nkululeko-0.95.1.dist-info/top_level.txt,sha256=bf1k1YKkqcXemNX_cUgoyKqQ3_GVErPqAY-53J36jkM,19
+nkululeko-0.95.1.dist-info/RECORD,,