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

nkululeko/models/model_xgb.py

@@ -1,18 +1,164 @@
 # model_xgb.py
 
+import os
 from xgboost import XGBClassifier
 
+import nkululeko.glob_conf as glob_conf
 from nkululeko.models.model import Model
 
 
 class XGB_model(Model):
-    """An XGBoost model"""
+    """An XGBoost model with early stopping support"""
 
     def __init__(self, df_train, df_test, feats_train, feats_test):
         super().__init__(df_train, df_test, feats_train, feats_test)
         self.name = "xgb"
         self.is_classifier = True
-        self.clf = XGBClassifier()  # set up the classifier
+
+        # Configure XGBoost parameters
+        xgb_params = {}
+
+        # Get early stopping configuration
+        self.early_stopping_rounds = self.util.config_val(
+            "MODEL", "early_stopping_rounds", False
+        )
+        self.eval_metric = self.util.config_val("MODEL", "eval_metric", "logloss")
+
+        # Set up other XGBoost parameters that can be configured
+        n_estimators = self.util.config_val("MODEL", "n_estimators", 100)
+        max_depth = self.util.config_val("MODEL", "max_depth", 6)
+        learning_rate = self.util.config_val("MODEL", "learning_rate", 0.3)
+        subsample = self.util.config_val("MODEL", "subsample", 1.0)
+
+        xgb_params["n_estimators"] = int(n_estimators)
+        xgb_params["max_depth"] = int(max_depth)
+        xgb_params["learning_rate"] = float(learning_rate)
+        xgb_params["subsample"] = float(subsample)
+
+        # Set random state for reproducibility
+        xgb_params["random_state"] = 42
+
+        # Add early stopping parameters to model initialization if configured
+        if self.early_stopping_rounds:
+            xgb_params["early_stopping_rounds"] = int(self.early_stopping_rounds)
+            xgb_params["eval_metric"] = self.eval_metric
+
+        # Initialize classifier with parameters
+        self.clf = XGBClassifier(**xgb_params)
+
+    def train(self):
+        """Train the XGBoost model with optional early stopping."""
+        # Check if NANs in features and handle them
+        if self.feats_train.isna().to_numpy().any():
+            self.util.debug(
+                "Model, train: replacing"
+                f" {self.feats_train.isna().sum().sum()} NANs with 0"
+            )
+            self.feats_train = self.feats_train.fillna(0)
+
+        feats = self.feats_train.to_numpy()
+        labels = self.df_train[self.target]
+
+        # Configure fitting parameters
+        fit_params = {}
+
+        # Check if early stopping is configured
+        if self.early_stopping_rounds:
+            # Check if we're in split3 mode (train/dev/test) where validation data is available
+            import ast
+
+            split3 = ast.literal_eval(
+                self.util.config_val("EXP", "traindevtest", "False")
+            )
+
+            if split3 and self.feats_test is not None and self.df_test is not None:
+                # In split3 mode, self.feats_test and self.df_test are actually the dev set
+                feats_dev = self.feats_test.to_numpy()
+                labels_dev = self.df_test[self.target]
+
+                # Handle NANs in dev features
+                if self.feats_test.isna().to_numpy().any():
+                    self.util.debug(
+                        "Model, dev: replacing"
+                        f" {self.feats_test.isna().sum().sum()} NANs with 0"
+                    )
+                    feats_dev = self.feats_test.fillna(0).to_numpy()
+
+                # Set up early stopping with validation data
+                eval_set = [(feats, labels), (feats_dev, labels_dev)]
+                fit_params["eval_set"] = eval_set
+                fit_params["verbose"] = True
+
+                self.util.debug(
+                    f"Training XGBoost with early stopping (using dev set):"
+                )
+                self.util.debug(
+                    f"  - early_stopping_rounds: {self.early_stopping_rounds}"
+                )
+                self.util.debug(f"  - eval_metric: {self.eval_metric}")
+                self.util.debug(f"  - validation set size: {feats_dev.shape[0]}")
+            else:
+                # For train/test split only: use a portion of training data for validation
+                from sklearn.model_selection import train_test_split
+
+                # Get validation split ratio (default 0.2 = 20% of training data)
+                val_split = float(
+                    self.util.config_val("MODEL", "validation_split", 0.2)
+                )
+
+                # Split training data into train and validation
+                feats_train_split, feats_val, labels_train_split, labels_val = (
+                    train_test_split(
+                        feats,
+                        labels,
+                        test_size=val_split,
+                        random_state=42,
+                        stratify=labels,
+                    )
+                )
+
+                # Set up early stopping with validation split
+                eval_set = [
+                    (feats_train_split, labels_train_split),
+                    (feats_val, labels_val),
+                ]
+                fit_params["eval_set"] = eval_set
+                fit_params["verbose"] = True
+
+                # Use the split training data for actual training
+                feats = feats_train_split
+                labels = labels_train_split
+
+                self.util.debug(
+                    f"Training XGBoost with early stopping (using validation split):"
+                )
+                self.util.debug(
+                    f"  - early_stopping_rounds: {self.early_stopping_rounds}"
+                )
+                self.util.debug(f"  - eval_metric: {self.eval_metric}")
+                self.util.debug(f"  - validation_split: {val_split}")
+                self.util.debug(f"  - training set size: {feats_train_split.shape[0]}")
+                self.util.debug(f"  - validation set size: {feats_val.shape[0]}")
+
+        # Handle class weights if configured
+        class_weight = self.util.config_val("MODEL", "class_weight", False)
+        if class_weight:
+            import sklearn.utils.class_weight
+
+            self.util.debug("using class weight")
+            classes_weights = sklearn.utils.class_weight.compute_sample_weight(
+                class_weight="balanced", y=labels
+            )
+            fit_params["sample_weight"] = classes_weights
+
+        # Train the model
+        self.clf.fit(feats, labels, **fit_params)
+
+        # Log information about the trained model
+        if hasattr(self.clf, "best_iteration"):
+            self.util.debug(f"Best iteration: {self.clf.best_iteration}")
+        if hasattr(self.clf, "best_score"):
+            self.util.debug(f"Best score: {self.clf.best_score}")
 
     def get_type(self):
         return "xgb"

nkululeko/models/tests/test_model_knn.py

@@ -0,0 +1,49 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from nkululeko.models.model_knn import KNN_model
+
+
+@pytest.fixture
+def mock_util():
+    mock = MagicMock()
+    mock.config_val.side_effect = lambda section, key, default: {
+        ("MODEL", "KNN_weights", "uniform"): "distance",
+        ("MODEL", "K_val", "5"): "3"
+    }[(section, key, default)]
+    return mock
+
+@pytest.fixture
+def dummy_data():
+    df_train = MagicMock()
+    df_test = MagicMock()
+    feats_train = MagicMock()
+    feats_test = MagicMock()
+    return df_train, df_test, feats_train, feats_test
+
+def test_knn_model_initialization(monkeypatch, mock_util, dummy_data):
+    with patch.object(KNN_model, "__init__", return_value=None):
+        model = KNN_model(*dummy_data)
+        model.util = mock_util
+        model.name = "knn"
+        from sklearn.neighbors import KNeighborsClassifier
+        model.clf = KNeighborsClassifier(n_neighbors=3, weights="distance")
+        model.is_classifier = True
+        assert model.name == "knn"
+        assert model.clf.get_params()["n_neighbors"] == 3
+        assert model.clf.get_params()["weights"] == "distance"
+        assert model.is_classifier is True
+
+def test_knn_model_default_params(monkeypatch, dummy_data):
+    mock_util = MagicMock()
+    mock_util.config_val.side_effect = lambda section, key, default: default
+    with patch.object(KNN_model, "__init__", return_value=None):
+        model = KNN_model(*dummy_data)
+        model.util = mock_util
+        model.name = "knn"
+        from sklearn.neighbors import KNeighborsClassifier
+        model.clf = KNeighborsClassifier(n_neighbors=5, weights="uniform")
+        model.is_classifier = True
+        assert model.clf.get_params()["n_neighbors"] == 5
+        assert model.clf.get_params()["weights"] == "uniform"

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/nkululeko.py

@@ -54,15 +54,6 @@ def doit(config_file):
     reports, last_epochs = expr.run()
     result = expr.get_best_report(reports).result.test
     expr.store_report()
-
-    # check if we want to export the model
-    o_path = util.config_val("EXP", "export_onnx", "False")
-    if eval(o_path):
-        print(f"Exporting ONNX model to {o_path}")
-        o_path = o_path.replace('"', '')
-        expr.runmgr.get_best_model().export_onnx(str(o_path))
-
-
     print("DONE")
     return result, int(np.asarray(last_epochs).min())
 

nkululeko/plots.py

@@ -1,5 +1,6 @@
 # plots.py
 import ast
+import os
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -87,9 +88,10 @@ class Plots:
 
     def plot_distributions(self, df, type_s="samples"):
         class_label, df = self._check_binning("class_label", df)
-        attributes = ast.literal_eval(
-            self.util.config_val("EXPL", "value_counts", False)
-        )
+        value_counts_conf = self.util.config_val("EXPL", "value_counts", False)
+        if not isinstance(value_counts_conf, str):
+            value_counts_conf = str(value_counts_conf)
+        attributes = ast.literal_eval(value_counts_conf)
         # always plot the distribution of the main attribute
         filename = f"{class_label}_distribution"
         if self.util.is_categorical(df[class_label]):
@@ -216,11 +218,11 @@ class Plots:
 
     def save_plot(self, ax, caption, header, filename, type_s):
         # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
+        fig_dir = os.path.dirname(self.util.get_path("fig_dir"))
         fig_plots = ax.figure
         # avoid warning
         # plt.tight_layout()
-        img_path = f"{fig_dir}{filename}_{type_s}.{self.format}"
+        img_path = os.path.join(fig_dir, f"{filename}_{type_s}.{self.format}")
         plt.savefig(img_path)
         plt.close(fig_plots)
         self.util.debug(f"Saved plot to {img_path}")
@@ -359,7 +361,7 @@ class Plots:
 
     def plot_durations(self, df, filename, sample_selection, caption=""):
         # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
+        fig_dir = os.path.join(self.util.get_path("fig_dir"), "..")
         try:
             ax = sns.histplot(df, x="duration", hue="class_label", kde=True)
         except AttributeError as ae:
@@ -376,7 +378,7 @@ class Plots:
         ax.set_ylabel("number of samples")
         fig = ax.figure
         # plt.tight_layout()
-        img_path = f"{fig_dir}{filename}_{sample_selection}.{self.format}"
+        img_path = os.path.join(fig_dir, f"{filename}_{sample_selection}.{self.format}")
         plt.savefig(img_path)
         plt.close(fig)
         self.util.debug(f"plotted durations to {img_path}")
@@ -393,14 +395,14 @@ class Plots:
         filename = "speakers"
         caption = "speakers"
         # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
+        fig_dir = os.path.join(self.util.get_path("fig_dir"), "..")
         sns.set_style("whitegrid")  # Set style for chart
         ax = df["speaker"].value_counts().plot(kind="pie", autopct="%1.1f%%")
         title = f"Speaker distr. for {sample_selection} {df.shape[0]}."
         ax.set_title(title)
         fig = ax.figure
         # plt.tight_layout()
-        img_path = f"{fig_dir}{filename}_{sample_selection}.{self.format}"
+        img_path = os.path.join(fig_dir, f"{filename}_{sample_selection}.{self.format}")
         plt.savefig(img_path)
         plt.close(fig)
         self.util.debug(f"plotted speakers to {img_path}")
@@ -415,7 +417,7 @@ class Plots:
 
     def describe_df(self, name, df, target, filename):
         """Make a stacked barplot of samples and speakers per sex and target values. speaker, gender and target columns must be present"""
-        fig_dir = self.util.get_path("fig_dir") + "../"  # one up because of the runs
+        fig_dir = self.util.get_path("fig_dir")  # + "../"  # one up because of the runs
         sampl_num = df.shape[0]
         sex_col = "gender"
         if target == "gender":
@@ -447,7 +449,7 @@ class Plots:
                     kind="bar", ax=axes, title=f"samples ({sampl_num})"
                 )
             # plt.tight_layout()
-            img_path = f"{fig_dir}{filename}.{self.format}"
+            img_path = os.path.join(fig_dir, f"{filename}.{self.format}")
             plt.savefig(img_path)
             fig.clear()
             plt.close(fig)
@@ -462,11 +464,12 @@ class Plots:
 
     def scatter_plot(self, feats, label_df, label, dimred_type):
         dim_num = int(self.util.config_val("EXPL", "scatter.dim", 2))
-        # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
+        # one up because of the runs (for explore module)
+        fig_dir = os.path.join(self.util.get_path("fig_dir"), "..")
         sample_selection = self.util.config_val("EXPL", "sample_selection", "all")
-        filename = f"{label}_{self.util.get_feattype_name()}_{sample_selection}_{dimred_type}_{str(dim_num)}d"
-        filename = f"{fig_dir}{filename}.{self.format}"
+        exp_name = self.util.get_name()
+        filename = f"{label}_{exp_name}_{self.util.get_feattype_name()}_{sample_selection}_{dimred_type}_{str(dim_num)}d"
+        filename = os.path.join(fig_dir, f"{filename}.{self.format}")
         self.util.debug(f"computing {dimred_type}, this might take a while...")
         data = None
         labels = label_df[label]
@@ -573,6 +576,7 @@ class Plots:
             self.util.error(f"wrong dimension number: {dim_num}")
         fig = ax.figure
         plt.savefig(filename)
+        self.util.debug(f"plotted {dimred_type} scatter plot to {filename}")
         fig.clear()
         plt.close(fig)
         glob_conf.report.add_item(
@@ -599,8 +603,10 @@ class Plots:
         # remove fullstops in the name
         feature_name = feature.replace(".", "-")
         # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
-        filename = f"{fig_dir}feat_dist_{title}_{feature_name}.{self.format}"
+        fig_dir = os.path.join(self.util.get_path("fig_dir"), "..")
+        filename = os.path.join(
+            fig_dir, f"feat_dist_{title}_{feature_name}.{self.format}"
+        )
         if self.util.is_categorical(df_labels[label]):
             df_plot = pd.DataFrame(
                 {label: df_labels[label], feature: df_features[feature]}
@@ -647,9 +653,9 @@ class Plots:
         # plt.tight_layout()
         # print(ax)
         # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
+        fig_dir = os.path.join(self.util.get_path("fig_dir"), "..")
         exp_name = self.util.get_exp_name(only_data=True)
-        filename = f"{fig_dir}{exp_name}EXPL_tree-plot.{self.format}"
+        filename = os.path.join(fig_dir, f"{exp_name}EXPL_tree-plot.{self.format}")
         fig = ax.figure
         fig.savefig(filename)
         fig.clear()

nkululeko/predict.py

@@ -1,8 +1,8 @@
 # predict.py
-# use some model and add automatically predicted labels to train and test splits
-# then save as a new dataset
+# use some model and add automatically predicted labels 
+# also can labels train and test splits then save as a new dataset
 
-r"""This script is used to call the nkululeko PREDICT framework.
+r"""This script is used to call the nkululeko PREDICT module.
 
 It loads a configuration file, creates a new experiment,
 and performs automatic prediction on the train and test datasets. The predicted labels are added to the datasets and
@@ -60,9 +60,11 @@ def main():
     if "class_label" in df.columns:
         df = df.drop(columns=[target])
         df = df.rename(columns={"class_label": target})
-    name = util.get_data_name() + "_predicted"
-    df.to_csv(f"{expr.data_dir}/{name}.csv")
-    util.debug(f"saved {name}.csv to {expr.data_dir}")
+    sample_selection = util.config_val("PREDICT", "sample_selection", "all")
+    name = f"{sample_selection}_predicted"
+    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/report.py

@@ -5,7 +5,6 @@ Collector class for report items collected during module processing.
 
 """
 
-from nkululeko.reporting.latex_writer import LatexWriter
 from nkululeko.utils.util import Util
 
 
@@ -31,7 +30,10 @@ class Report:
                 print("\t" + c.contents)
 
     def export_latex(self):
-        lw = LatexWriter()
-        for topic in self.report_items:
-            lw.add_items_for_section(topic, self.report_items[topic])
-        lw.finish_doc()
+        if str(self.util.config_val("REPORT", "show", "False")).lower() == "true":
+            from nkululeko.reporting.latex_writer import LatexWriter
+
+            lw = LatexWriter()
+            for topic in self.report_items:
+                lw.add_items_for_section(topic, self.report_items[topic])
+            lw.finish_doc()

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
@@ -152,11 +153,14 @@ class Reporter:
             probas["truth"] = self.truths
             try:
                 le = glob_conf.label_encoder
-                mapping = dict(zip(le.classes_, range(len(le.classes_))))
-                mapping_reverse = {value: key for key, value in mapping.items()}
-                probas = probas.rename(columns=mapping_reverse)
-                probas["predicted"] = probas["predicted"].map(mapping_reverse)
-                probas["truth"] = probas["truth"].map(mapping_reverse)
+                if le is not None:
+                    mapping = dict(zip(le.classes_, range(len(le.classes_))))
+                    mapping_reverse = {value: key for key, value in mapping.items()}
+                    probas = probas.rename(columns=mapping_reverse)
+                    probas["predicted"] = probas["predicted"].map(mapping_reverse)
+                    probas["truth"] = probas["truth"].map(mapping_reverse)
+                else:
+                    self.util.debug("Label encoder is None, skipping label mapping")
             except AttributeError as ae:
                 self.util.debug(f"Can't label categories: {ae}")
             # compute entropy per sample
@@ -170,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