nkululeko 0.82.4__py3-none-any.whl → 0.83.1__py3-none-any.whl

nkululeko/constants.py

@@ -1,2 +1,2 @@
-VERSION="0.82.4"
+VERSION="0.83.1"
 SAMPLING_RATE = 16000

nkululeko/experiment.py

@@ -23,7 +23,7 @@ from nkululeko.plots import Plots
 from nkululeko.reporting.report import Report
 from nkululeko.runmanager import Runmanager
 from nkululeko.scaler import Scaler
-from nkululeko.test_predictor import Test_predictor
+from nkululeko.test_predictor import TestPredictor
 from nkululeko.utils.util import Util
 
 
@@ -672,10 +672,11 @@ class Experiment:
     def predict_test_and_save(self, result_name):
         model = self.runmgr.get_best_model()
         model.set_testdata(self.df_test, self.feats_test)
-        test_predictor = Test_predictor(
+        test_predictor = TestPredictor(
             model, self.df_test, self.label_encoder, result_name
         )
-        test_predictor.predict_and_store()
+        result = test_predictor.predict_and_store()
+        return result
 
     def load(self, filename):
         f = open(filename, "rb")

nkululeko/modelrunner.py

@@ -2,18 +2,16 @@
 
 import pandas as pd
 
-from nkululeko.utils.util import Util
 from nkululeko import glob_conf
-import nkululeko.glob_conf as glob_conf
+from nkululeko.utils.util import Util
 
 
 class Modelrunner:
-    """
-    Class to model one run
-    """
+    """Class to model one run."""
 
     def __init__(self, df_train, df_test, feats_train, feats_test, run):
-        """Constructor setting up the dataframes
+        """Constructor setting up the dataframes.
+
         Args:
             df_train: train dataframe
             df_test: test dataframe

nkululeko/nkuluflag.py

@@ -2,13 +2,16 @@ import argparse
 import configparser
 import os
 import os.path
+import sys
 
 from nkululeko.nkululeko import doit as nkulu
+from nkululeko.test import do_it as test_mod
 
 
-def do_it(src_dir):
+def doit(cla):
     parser = argparse.ArgumentParser(description="Call the nkululeko framework.")
     parser.add_argument("--config", help="The base configuration")
+    parser.add_argument("--mod", default="nkulu", help="Which nkululeko module to call")
     parser.add_argument("--data", help="The databases", nargs="*", action="append")
     parser.add_argument(
         "--label", nargs="*", help="The labels for the target", action="append"
@@ -25,20 +28,23 @@ def do_it(src_dir):
     parser.add_argument("--model", default="xgb", help="The model type")
     parser.add_argument("--feat", default="['os']", help="The feature type")
     parser.add_argument("--set", help="The opensmile set")
-    parser.add_argument("--with_os", help="To add os features")
     parser.add_argument("--target", help="The target designation")
     parser.add_argument("--epochs", help="The number of epochs")
     parser.add_argument("--runs", help="The number of runs")
     parser.add_argument("--learning_rate", help="The learning rate")
     parser.add_argument("--drop", help="The dropout rate [0:1]")
 
-    args = parser.parse_args()
+    args = parser.parse_args(cla)
 
     if args.config is not None:
         config_file = args.config
     else:
         print("ERROR: need config file")
         quit(-1)
+
+    if args.mod is not None:
+        nkulu_mod = args.mod
+
     # test if config is there
     if not os.path.isfile(config_file):
         print(f"ERROR: no such file {config_file}")
@@ -86,10 +92,17 @@ def do_it(src_dir):
     with open(tmp_config, "w") as tmp_file:
         config.write(tmp_file)
 
-    result, last_epoch = nkulu(tmp_config)
+    result, last_epoch = 0, 0
+    if nkulu_mod == "nkulu":
+        result, last_epoch = nkulu(tmp_config)
+    elif nkulu_mod == "test":
+        result, last_epoch = test_mod(tmp_config, "test_results.csv")
+    else:
+        print(f"ERROR: unknown module: {nkulu_mod}, should be [nkulu | test]")
     return result, last_epoch
 
 
 if __name__ == "__main__":
-    cwd = os.path.dirname(os.path.abspath(__file__))
-    do_it(cwd)  # sys.argv[1])
+    cla = sys.argv
+    cla.pop(0)
+    doit(cla)  # sys.argv[1])

nkululeko/reporting/reporter.py

@@ -55,6 +55,7 @@ class Reporter:
         self.run = run
         self.epoch = epoch
         self.__set_measure()
+        self.filenameadd = ""
         self.cont_to_cat = False
         if len(self.truths) > 0 and len(self.preds) > 0:
             if self.util.exp_is_classification():
@@ -206,7 +207,7 @@ class Reporter:
                 f"Confusion Matrix, UAR: {uar_str} "
                 + f"(+-{up_str}/{low_str}) {reg_res}"
             )
-        img_path = f"{fig_dir}{plot_name}.{self.format}"
+        img_path = f"{fig_dir}{plot_name}{self.filenameadd}.{self.format}"
         plt.savefig(img_path)
         fig.clear()
         plt.close(fig)
@@ -228,14 +229,17 @@ class Reporter:
         )
         # print(rpt)
         self.util.debug(rpt)
-        file_name = f"{res_dir}{self.util.get_exp_name()}_conf.txt"
+        file_name = f"{res_dir}{self.util.get_exp_name()}{self.filenameadd}_conf.txt"
         with open(file_name, "w") as text_file:
             text_file.write(rpt)
 
+    def set_filename_add(self, my_string):
+        self.filenameadd = f"_{my_string}"
+
     def print_results(self, epoch):
         """Print all evaluation values to text file."""
         res_dir = self.util.get_path("res_dir")
-        file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}.txt"
+        file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}{self.filenameadd}.txt"
         if self.util.exp_is_classification():
             labels = glob_conf.labels
             try:

nkululeko/test.py

@@ -10,20 +10,7 @@ from nkululeko.experiment import Experiment
 from nkululeko.utils.util import Util
 
 
-def main(src_dir):
-    parser = argparse.ArgumentParser(
-        description="Call the nkululeko TEST framework.")
-    parser.add_argument("--config", default="exp.ini",
-                        help="The base configuration")
-    parser.add_argument(
-        "--outfile",
-        default="my_results.csv",
-        help="File name to store the predictions",
-    )
-
-    args = parser.parse_args()
-
-    config_file = args.config
+def do_it(config_file, outfile):
 
     # test if the configuration file exists
     if not os.path.isfile(config_file):
@@ -48,10 +35,28 @@ def main(src_dir):
     expr.load(f"{util.get_save_name()}")
     expr.fill_tests()
     expr.extract_test_feats()
-    expr.predict_test_and_save(args.outfile)
+    result = expr.predict_test_and_save(outfile)
 
     print("DONE")
 
+    return result, 0
+
+
+def main(src_dir):
+    parser = argparse.ArgumentParser(description="Call the nkululeko TEST framework.")
+    parser.add_argument("--config", default="exp.ini", help="The base configuration")
+    parser.add_argument(
+        "--outfile",
+        default="my_results.csv",
+        help="File name to store the predictions",
+    )
+    args = parser.parse_args()
+    if args.config is not None:
+        config_file = args.config
+    else:
+        config_file = f"{src_dir}/exp.ini"
+    do_it(config_file, args.outfile)
+
 
 if __name__ == "__main__":
     cwd = os.path.dirname(os.path.abspath(__file__))

nkululeko/test_predictor.py

@@ -1,21 +1,25 @@
-""" test_predictor.py
+"""test_predictor.py.
+
     Predict targets from a model and save as csv file.
 
 """
 
-import nkululeko.glob_conf as glob_conf
-from nkululeko.utils.util import Util
+import ast
+
+import numpy as np
 import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+
 from nkululeko.data.dataset import Dataset
 from nkululeko.feature_extractor import FeatureExtractor
+import nkululeko.glob_conf as glob_conf
 from nkululeko.scaler import Scaler
-import numpy as np
-from sklearn.preprocessing import LabelEncoder
+from nkululeko.utils.util import Util
 
 
-class Test_predictor:
+class TestPredictor:
     def __init__(self, model, orig_df, labenc, name):
-        """Constructor setting up name and configuration"""
+        """Constructor setting up name and configuration."""
         self.model = model
         self.orig_df = orig_df
         self.label_encoder = labenc
@@ -25,6 +29,7 @@ class Test_predictor:
 
     def predict_and_store(self):
         label_data = self.util.config_val("DATA", "label_data", False)
+        result = 0
         if label_data:
             data = Dataset(label_data)
             data.load()
@@ -49,7 +54,15 @@ class Test_predictor:
             df[self.target] = labelenc.inverse_transform(predictions.tolist())
             df.to_csv(self.name)
         else:
+            test_dbs = ast.literal_eval(glob_conf.config["DATA"]["tests"])
+            test_dbs_string = "_".join(test_dbs)
             predictions = self.model.get_predictions()
+            report = self.model.predict()
+            result = report.result.get_result()
+            report.set_filename_add(f"test-{test_dbs_string}")
+            self.util.print_best_results([report])
+            report.plot_confmatrix(self.util.get_plot_name(), 0)
+            report.print_results(0)
             # print(predictions)
             # df = pd.DataFrame(index=self.orig_df.index)
             # df["speaker"] = self.orig_df["speaker"]
@@ -63,3 +76,4 @@ class Test_predictor:
                 df = df.rename(columns={"class_label": target})
             df.to_csv(self.name)
         self.util.debug(f"results stored in {self.name}")
+        return result

{nkululeko-0.82.4.dist-info → nkululeko-0.83.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.82.4
+Version: 0.83.1
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -333,6 +333,14 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.83.1
+--------------
+* add test module to nkuluflag
+
+Version 0.83.0
+--------------
+* test module now prints out reports
+
 Version 0.82.4
 --------------
 * fixed bug in wavlm 

{nkululeko-0.82.4.dist-info → nkululeko-0.83.1.dist-info}/RECORD

@@ -2,31 +2,30 @@ nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
 nkululeko/aug_train.py,sha256=YhuZnS_WVWnun9G-M6g5n6rbRxoVREz6Zh7k6qprFNQ,3194
 nkululeko/augment.py,sha256=4MG0apTAG5RgkuJrYEjGgDdbodZWi_HweSPNI1JJ5QA,3051
 nkululeko/cacheddataset.py,sha256=lIJ6hUo5LoxSrzXtWV8mzwO7wRtUETWnOQ4ws2XfL1E,969
-nkululeko/constants.py,sha256=kp-581CniawYq15MP-eOYf2iEPJCoCdhJ8W3kRUgPhs,39
+nkululeko/constants.py,sha256=i6-Vtyje9xE8w8o3lG27IiJczQFyrNbsxiXs7b4-q28,39
 nkululeko/demo.py,sha256=55kNFA2helMhOxD4yZuKg1JWDtlUUpxm-6uAnroIydI,3264
 nkululeko/demo_feats.py,sha256=sAeGFojhEj9WEDFtG3SzPBmyYJWLF2rkbpp65m8Ujo4,2025
 nkululeko/demo_predictor.py,sha256=-ggSHc3DXxRzjzcGB4qFBOMvKsfUdTkkde50BDrS9dA,4755
-nkululeko/experiment.py,sha256=CSEvQxK2_tzJyND5sUHQSc6MkRp1g6EVam8JX8txqps,29576
+nkululeko/experiment.py,sha256=aueWoKJCQx8wU9daosh6n7ZDGhT2cfo_9Av5HIfN1_w,29605
 nkululeko/explore.py,sha256=2wdoGRqldvsN1zCiWk0quSDgHHHUoF2UZOWQ1r-2OLM,2310
 nkululeko/export.py,sha256=mHeEAAmtZuxdyebLlbSzPrHSi9OMgJHbk35d3DTxRBc,4632
 nkululeko/feature_extractor.py,sha256=8mssYKmo4LclVI-hiLmJEDZ0ZPyDavFG2YwtXcrGzwM,3976
 nkululeko/file_checker.py,sha256=LoLnL8aHpW-axMQ46qbqrManTs5otG9ShpEZuz9iRSk,3474
 nkululeko/filter_data.py,sha256=w-X2mhKdYr5DxDIz50E5yzO6Jmzk4jjDBoXsgOOVtcA,7222
 nkululeko/glob_conf.py,sha256=iHiVSxDYgmYwdx6z0HuGUMSWrfZfufPHxHb60q2dLRY,453
-nkululeko/modelrunner.py,sha256=GuYsmUGSmJ0QxXxR8k0TZ47IDMtdGIMbm5nMq4Ix6tU,9335
+nkululeko/modelrunner.py,sha256=GwDXcE2gDQXat4W0-HhHQ1BcUNCRBXMBQ4QycfHp_5c,9288
 nkululeko/multidb.py,sha256=fG3VukEWP1vreVN4gB1IRXxwwg4jLftsSEYtu0o1f78,5634
-nkululeko/nkuluflag.py,sha256=FCetTfgH69u4AwENgeCKVi3vBIR10Di67SfbupGQqfc,3354
+nkululeko/nkuluflag.py,sha256=PGWSmZz-PiiHLgcZJAoGOI_Y-sZDVI1ksB8p5r7riWM,3725
 nkululeko/nkululeko.py,sha256=Kn3s2E3yyH8cJ7z6lkMxrnqtCxTu7-qfe9Zr_ONTD5g,1968
 nkululeko/plots.py,sha256=K88ZRPFGX_r03BT742H06Dde20xZYdltv7dxjgUiAFA,23025
 nkululeko/predict.py,sha256=sF091sSSLnEWcISx9ZcULLie3tY5XeFsQJd6b3vrxFg,2409
-nkululeko/reporter.py,sha256=mCy8er8z4e5hJ7XbOyy6BgZYZM6Lz-EKXHh4zlT0Zc8,12427
 nkululeko/resample.py,sha256=3WbxkwgyTe_fW38046Rjxk3knOkFdhqn2C4nfhbUurQ,2287
 nkululeko/runmanager.py,sha256=eTM1DNQKt1lxYhzt4vZyZluPXW9sWlIJHNQzex4lkJU,7624
 nkululeko/scaler.py,sha256=4nkIqoajkIkuTPK0Z02ifMN_awl6fP_i-GBYdoGYgGM,4101
 nkululeko/segment.py,sha256=YLKckX44tbvTb3LrdgYw9X4guzuF27sutl92z9DkpZU,4835
 nkululeko/syllable_nuclei.py,sha256=Sky-C__MeUDaxqHnDl2TGLLYOYvsahD35TUjWGeG31k,10047
-nkululeko/test.py,sha256=JRoLgqQJEhAIGetw-qlOUihSTTQ7O8DYafB0FlQESIQ,1525
-nkululeko/test_predictor.py,sha256=L2njNydYTX85_7RhHjfk1MN4JwE21tsBVuX4fY-XEjc,2753
+nkululeko/test.py,sha256=1w624vo5KTzmFC8BUStGlLDmIEAFuJUz7J0W-gp7AxI,1677
+nkululeko/test_predictor.py,sha256=_w5J8CxH6hmW3mLTKbdfmywl5QpdNAnW1Y8TE5GtlfE,3237
 nkululeko/augmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/augmenting/augmenter.py,sha256=XAt0dpmlnKxqyysqCgV3rcz-pRIvOz7rU7dmGDCVAzs,2905
 nkululeko/augmenting/randomsplicer.py,sha256=Z5rxdKKUpuncLWuTS6xVfVKUeVbeiYU_dLRHQ5fcg4Y,2669
@@ -95,7 +94,7 @@ nkululeko/reporting/defines.py,sha256=IsY1YgKRMaABpylVKjBJgJ5bNCEbGCVA_E6pivraqS
 nkululeko/reporting/latex_writer.py,sha256=qiCRSmB4KOD_za4oHu5x-PhwjZohzfo8wecMOwlXZwc,1886
 nkululeko/reporting/report.py,sha256=W0rcigDdjBvxZQ3pZja_gvToILYvaZ1BFtnN2qFRfYI,1060
 nkululeko/reporting/report_item.py,sha256=siWeGNgo4bAE46YBMNcsdf3jTMTy76BO9Fi6DTvDig4,533
-nkululeko/reporting/reporter.py,sha256=wwpY0gA-8E8d26XH3DSmXm3X0BkBw2Y0YyEiUiNU_Y0,12670
+nkululeko/reporting/reporter.py,sha256=eLqwKEUTQ7v5CedzhZP2617qmXGcvi0rjyyFLOBdxtQ,12841
 nkululeko/reporting/result.py,sha256=nSN5or-Py2GPRWHkWpGRh7UCi1W0er7WLEHz8fYLk-A,742
 nkululeko/segmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/segmenting/seg_inaspeechsegmenter.py,sha256=pmLHuXsaqvcdYxB4PSW9l1mbQWZZBJFhi_CGabqydas,1947
@@ -104,8 +103,8 @@ nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=UiGAtZRWYjHSvlmPaTMtzyNNGE6qaLaxQkybctS7iRM,4021
 nkululeko/utils/stats.py,sha256=1yUq0FTOyqkU8TwUocJRYdJaqMU5SlOBBRUun9STo2M,2829
 nkululeko/utils/util.py,sha256=_Z6OMJ3f-8TdETW9eqJYY5hwNRS5XCt9azzRnqoTTZE,12330
-nkululeko-0.82.4.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.82.4.dist-info/METADATA,sha256=iVA5K6coH1oLy918OgAZoq6wqFXcfYIcuZBV1dOnI2g,35950
-nkululeko-0.82.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-nkululeko-0.82.4.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.82.4.dist-info/RECORD,,
+nkululeko-0.83.1.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.83.1.dist-info/METADATA,sha256=EgPYOS_ELZQmEvPWlX-klt8gmo59suFFL_HDptU474w,36080
+nkululeko-0.83.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+nkululeko-0.83.1.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.83.1.dist-info/RECORD,,

nkululeko/reporter.py

@@ -1,332 +0,0 @@
-"""Reporter module.
-
-This module contains the Reporter class which is responsible for generating reports.
-"""
-
-
-import ast
-import glob
-import json
-import math
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.stats import pearsonr
-from sklearn.metrics import (
-    ConfusionMatrixDisplay,
-    accuracy_score,
-    classification_report,
-    confusion_matrix,
-    mean_absolute_error,
-    mean_squared_error,
-    r2_score,
-    recall_score,
-)
-from sklearn.utils import resample
-
-import nkululeko.glob_conf as glob_conf
-from nkululeko.reporting.defines import Header
-from nkululeko.reporting.report_item import ReportItem
-from nkululeko.result import Result
-from nkululeko.utils.util import Util
-
-
-class Reporter:
-    def __set_measure(self):
-        if self.util.exp_is_classification():
-            self.MEASURE = "UAR"
-            self.result.measure = self.MEASURE
-            self.is_classification = True
-        else:
-            self.is_classification = False
-            self.measure = self.util.config_val("MODEL", "measure", "mse")
-            if self.measure == "mse":
-                self.MEASURE = "MSE"
-                self.result.measure = self.MEASURE
-            elif self.measure == "mae":
-                self.MEASURE = "MAE"
-                self.result.measure = self.MEASURE
-            elif self.measure == "ccc":
-                self.MEASURE = "CCC"
-                self.result.measure = self.MEASURE
-
-    def __init__(self, truths, preds, run, epoch):
-        """Initialization with ground truth und predictions vector"""
-        self.util = Util("reporter")
-        self.format = self.util.config_val("PLOT", "format", "png")
-        self.truths = truths
-        self.preds = preds
-        self.result = Result(0, 0, 0, 0, "unknown")
-        self.run = run
-        self.epoch = epoch
-        self.__set_measure()
-        self.cont_to_cat = False
-        if len(self.truths) > 0 and len(self.preds) > 0:
-            if self.util.exp_is_classification():
-                self.result.test = recall_score(
-                    self.truths, self.preds, average="macro"
-                )
-                self.result.loss = 1 - accuracy_score(self.truths, self.preds)
-            else:
-                # regression experiment
-                if self.measure == "mse":
-                    self.result.test = mean_squared_error(
-                        self.truths, self.preds)
-                elif self.measure == "mae":
-                    self.result.test = mean_absolute_error(
-                        self.truths, self.preds)
-                elif self.measure == "ccc":
-                    self.result.test = self.ccc(self.truths, self.preds)
-                    if math.isnan(self.result.test):
-                        self.util.debug(f"Truth: {self.truths}")
-                        self.util.debug(f"Predict.: {self.preds}")
-                        self.util.debug(f"Result is NAN: setting to -1")
-                        self.result.test = -1
-                else:
-                    self.util.error(f"unknown measure: {self.measure}")
-
-                # train and loss are being set by the model
-
-    def set_id(self, run, epoch):
-        """Make the report identifiable with run and epoch index"""
-        self.run = run
-        self.epoch = epoch
-
-    def continuous_to_categorical(self):
-        if self.cont_to_cat:
-            return
-        self.cont_to_cat = True
-        bins = ast.literal_eval(glob_conf.config["DATA"]["bins"])
-        self.truths = np.digitize(self.truths, bins) - 1
-        self.preds = np.digitize(self.preds, bins) - 1
-
-    def plot_confmatrix(self, plot_name, epoch):
-        if not self.util.exp_is_classification():
-            self.continuous_to_categorical()
-        self._plot_confmat(self.truths, self.preds, plot_name, epoch)
-
-
-def plot_per_speaker(self, result_df, plot_name, function):
-    """Plot a confusion matrix with the mode category per speakers.
-
-    This function creates a confusion matrix for each speaker in the result_df.
-    The result_df should contain the columns: preds, truths and speaker.
-
-    Args:
-        * result_df: a pandas dataframe with columns: preds, truths and speaker
-        * plot_name: a string with the name of the plot
-        * function: a string with the function to use for each speaker, 
-        can be 'mode' or 'mean'
-
-    Returns:
-        * None
-    """
-    # Initialize empty arrays for predictions and truths
-    pred = np.zeros(0)
-    truth = np.zeros(0)
-
-    # Iterate over each speaker
-    for s in result_df.speaker.unique():
-        # Filter the dataframe for the current speaker
-        s_df = result_df[result_df.speaker == s]
-
-        # Get the mode or mean prediction for the current speaker
-        mode = s_df.pred.mode().iloc[-1]
-        mean = s_df.pred.mean()
-        if function == "mode":
-            s_df.pred = mode
-        elif function == "mean":
-            s_df.pred = mean
-        else:
-            self.util.error(f"unknown function {function}")
-
-        # Append the current speaker's predictions and truths to the arrays
-        pred = np.append(pred, s_df.pred.values)
-        truth = np.append(truth, s_df["truth"].values)
-
-    # If the experiment is not a classification or continuous to categorical conversion was performed,
-    # convert the truths and predictions to categorical
-    if not (self.is_classification or self.cont_to_cat):
-        bins = ast.literal_eval(glob_conf.config["DATA"]["bins"])
-        truth = np.digitize(truth, bins) - 1
-        pred = np.digitize(pred, bins) - 1
-
-    # Plot the confusion matrix for the speakers
-    self._plot_confmat(truth, pred.astype("int"), plot_name, 0)
-
-    def _plot_confmat(self, truths, preds, plot_name, epoch):
-        # print(truths)
-        # print(preds)
-        fig_dir = self.util.get_path("fig_dir")
-        labels = glob_conf.labels
-        fig = plt.figure()  # figsize=[5, 5]
-        uar = recall_score(truths, preds, average="macro")
-        acc = accuracy_score(truths, preds)
-        cm = confusion_matrix(
-            truths, preds, normalize=None
-        )  # normalize must be one of {'true', 'pred', 'all', None}
-        if cm.shape[0] != len(labels):
-            self.util.error(
-                f"mismatch between confmatrix dim ({cm.shape[0]}) and labels"
-                f" length ({len(labels)}: {labels})"
-            )
-        try:
-            disp = ConfusionMatrixDisplay(
-                confusion_matrix=cm, display_labels=labels
-            ).plot(cmap="Blues")
-        except ValueError:
-            disp = ConfusionMatrixDisplay(
-                confusion_matrix=cm,
-                display_labels=list(labels).remove("neutral"),
-            ).plot(cmap="Blues")
-
-        reg_res = ""
-        if not self.is_classification:
-            reg_res = f", {self.MEASURE}: {self.result.test:.3f}"
-
-        if epoch != 0:
-            plt.title(
-                f"Confusion Matrix, UAR: {uar:.3f}{reg_res}, Epoch: {epoch}")
-        else:
-            plt.title(f"Confusion Matrix, UAR: {uar:.3f}{reg_res}")
-        img_path = f"{fig_dir}{plot_name}.{self.format}"
-        plt.savefig(img_path)
-        fig.clear()
-        plt.close(fig)
-        plt.savefig(img_path)
-        plt.close(fig)
-        glob_conf.report.add_item(
-            ReportItem(
-                Header.HEADER_RESULTS,
-                self.util.get_model_description(),
-                "Confusion matrix",
-                img_path,
-            )
-        )
-
-        res_dir = self.util.get_path("res_dir")
-        uar = int(uar * 1000) / 1000.0
-        acc = int(acc * 1000) / 1000.0
-        rpt = f"epoch: {epoch}, UAR: {uar}, ACC: {acc}"
-        # print(rpt)
-        self.util.debug(rpt)
-        file_name = f"{res_dir}{self.util.get_exp_name()}_conf.txt"
-        with open(file_name, "w") as text_file:
-            text_file.write(rpt)
-
-    def print_results(self, epoch):
-        """Print all evaluation values to text file"""
-        res_dir = self.util.get_path("res_dir")
-        file_name = f"{res_dir}{self.util.get_exp_name()}_{epoch}.txt"
-        if self.util.exp_is_classification():
-            labels = glob_conf.labels
-            try:
-                rpt = classification_report(
-                    self.truths,
-                    self.preds,
-                    target_names=labels,
-                    output_dict=True,
-                )
-            except ValueError as e:
-                self.util.debug(
-                    "Reporter: caught a ValueError when trying to get"
-                    " classification_report: " + e
-                )
-                rpt = self.result.to_string()
-            with open(file_name, "w") as text_file:
-                c_ress = list(range(len(labels)))
-                for i, l in enumerate(labels):
-                    c_res = rpt[l]["f1-score"]
-                    c_ress[i] = float(f"{c_res:.3f}")
-                self.util.debug(f"labels: {labels}")
-                f1_per_class = f"result per class (F1 score): {c_ress}"
-                self.util.debug(f1_per_class)
-                rpt_str = f"{json.dumps(rpt)}\n{f1_per_class}"
-                text_file.write(rpt_str)
-                glob_conf.report.add_item(
-                    ReportItem(
-                        Header.HEADER_RESULTS,
-                        f"Classification result {self.util.get_model_description()}",
-                        rpt_str,
-                    )
-                )
-
-        else:  # regression
-            result = self.result.test
-            r2 = r2_score(self.truths, self.preds)
-            pcc = pearsonr(self.truths, self.preds)[0]
-            measure = self.util.config_val("MODEL", "measure", "mse")
-            with open(file_name, "w") as text_file:
-                text_file.write(
-                    f"{measure}: {result:.3f}, r_2: {r2:.3f}, pcc {pcc:.3f}"
-                )
-
-    def make_conf_animation(self, out_name):
-        import imageio
-
-        fig_dir = self.util.get_path("fig_dir")
-        filenames = glob.glob(
-            fig_dir + f"{self.util.get_plot_name()}*_?_???_cnf.png")
-        images = []
-        for filename in filenames:
-            images.append(imageio.imread(filename))
-        fps = self.util.config_val("PLOT", "fps", "1")
-        try:
-            imageio.mimsave(fig_dir + out_name, images, fps=int(fps))
-        except RuntimeError as e:
-            self.util.error("error writing anim gif: " + e)
-
-    def get_result(self):
-        return self.result
-
-    def plot_epoch_progression(self, reports, out_name):
-        fig_dir = self.util.get_path("fig_dir")
-        results, losses, train_results, losses_eval = [], [], [], []
-        for r in reports:
-            results.append(r.get_result().test)
-            losses.append(r.get_result().loss)
-            train_results.append(r.get_result().train)
-            losses_eval.append(r.get_result().loss_eval)
-
-        # do a plot per run
-        # scale the losses so they fit on the picture
-        losses, results, train_results, losses_eval = (
-            np.asarray(losses),
-            np.asarray(results),
-            np.asarray(train_results),
-            np.asarray(losses_eval),
-        )
-
-        if np.all((results > 1)):
-            # scale down values
-            results = results / 100.0
-            train_results = train_results / 100.0
-        # if np.all((losses < 1)):
-        # scale up values
-        plt.figure(dpi=200)
-        plt.plot(train_results, "green", label="train set")
-        plt.plot(results, "red", label="dev set")
-        plt.plot(losses, "black", label="losses")
-        plt.plot(losses_eval, "grey", label="losses_eval")
-        plt.xlabel("epochs")
-        plt.ylabel(f"{self.MEASURE}")
-        plt.legend()
-        plt.savefig(f"{fig_dir}{out_name}.{self.format}")
-        plt.close()
-
-    @staticmethod
-    def ccc(ground_truth, prediction):
-        mean_gt = np.mean(ground_truth, 0)
-        mean_pred = np.mean(prediction, 0)
-        var_gt = np.var(ground_truth, 0)
-        var_pred = np.var(prediction, 0)
-        v_pred = prediction - mean_pred
-        v_gt = ground_truth - mean_gt
-        cor = sum(v_pred * v_gt) / \
-            (np.sqrt(sum(v_pred**2)) * np.sqrt(sum(v_gt**2)))
-        sd_gt = np.std(ground_truth)
-        sd_pred = np.std(prediction)
-        numerator = 2 * cor * sd_gt * sd_pred
-        denominator = var_gt + var_pred + (mean_gt - mean_pred) ** 2
-        ccc = numerator / denominator
-        return ccc