radnn 0.0.3__tar.gz → 0.0.5__tar.gz

{radnn-0.0.3/src/radnn.egg-info → radnn-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: radnn
-Version: 0.0.3
+Version: 0.0.5
 Summary: Rapid Deep Neural Networks
 Author-email: "Pantelis I. Kaplanoglou" <pikaplanoglou@ihu.gr>
 License: MIT License

{radnn-0.0.3 → radnn-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "radnn"
-version = "0.0.3"
+version = "0.0.5"
 description = "Rapid Deep Neural Networks"
 readme = "README.md"
 authors = [

{radnn-0.0.3 → radnn-0.0.5}/src/radnn/__init__.py

@@ -1,5 +1,6 @@
 # Version 0.0.3  [2025-01-25]
-__version__ = "0.0.3"
+# Version 0.0.5  [2025-01-26]
+__version__ = "0.0.5"
 
 
 from .system import FileStore, FileSystem

radnn-0.0.5/src/radnn/core.py

@@ -0,0 +1,74 @@
+import sys
+import socket
+import platform
+import subprocess
+from datetime import datetime
+import importlib.util
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+def is_opencv_installed():
+    return importlib.util.find_spec("cv2") is not None
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+def system_name() -> str:
+  return MLInfrastructure.host_name(False)
+# ----------------------------------------------------------------------------------------------------------------------
+def now_iso():
+  return datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+# ----------------------------------------------------------------------------------------------------------------------
+def shell_command_output(command_string):
+  oOutput = subprocess.check_output(command_string, shell=True)
+  oOutputLines = oOutput.decode().splitlines()
+
+  oResult = []
+  for sLine in oOutputLines:
+      oResult.append(sLine)
+
+  return oResult
+# ----------------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+#TODO: macOS support
+
+class MLInfrastructure(object):
+  # ----------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def is_linux(cls):
+    return not (cls.is_windows or cls.is_colab)
+  # ----------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def is_windows(cls):
+    sPlatform = platform.system()
+    return (sPlatform == "Windows")
+  # ----------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def is_colab(cls):
+    return "google.colab" in sys.modules
+  # ----------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def host_name(cls, is_using_ip_address=True) -> str:
+    sPlatform = platform.system()
+    sHostName = socket.gethostname()
+    sIPAddress = socket.gethostbyname(sHostName)
+
+    bIsColab = "google.colab" in sys.modules
+    if bIsColab:
+      sResult = "(colab)"
+      if is_using_ip_address:
+        sResult += "-" + sIPAddress
+    else:
+      if sPlatform == "Windows":
+        sResult = "(windows)-" + sHostName
+      else:
+        sResult = "(linux)-" + sHostName
+    return sResult
+  # ----------------------------------------------------------------------------------------------------------------------

radnn-0.0.5/src/radnn/evaluation/__init__.py

@@ -0,0 +1 @@
+from .evaluate_classification import EvaluateClassification

radnn-0.0.5/src/radnn/evaluation/evaluate_classification.py

@@ -0,0 +1,113 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2020-2025 Pantelis I. Kaplanoglou
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# ......................................................................................
+
+import numpy as np
+from sklearn import metrics
+
+
+# ==============================================================================================================================
+class EvaluateClassification(object):
+  # --------------------------------------------------------------------------------------------------------------
+  def __init__(self, actual_classes, predicted_classes, probabilities=None):
+    self.actual_classes = actual_classes
+    self.predicted_classes = predicted_classes
+    self.confusion_matrix = np.asarray(metrics.confusion_matrix(self.actual_classes, self.predicted_classes))
+
+    self.accuracy = metrics.accuracy_score(self.actual_classes, self.predicted_classes)
+    self.precision, self.recall, self.f1score, self.support = metrics.precision_recall_fscore_support(
+      self.actual_classes, self.predicted_classes, average=None)
+    self.average_precision, self.average_recall, self.average_f1score, self.average_support = metrics.precision_recall_fscore_support(
+      self.actual_classes, self.predicted_classes, average='weighted')
+
+    if probabilities is not None:
+      self.auc = metrics.roc_auc_score(actual_classes, probabilities)
+    else:
+      self.auc = None
+
+
+    self.true_neg = self.confusion_matrix[0][0]
+    self.false_pos = self.confusion_matrix[0][1]
+    self.false_neg = self.confusion_matrix[1][0]
+    self.true_pos = self.confusion_matrix[1][1]
+
+    self.class_count = None
+  # --------------------------------------------------------------------------------------------------------------
+  def print_confusion_matrix(self):
+    nSize = len(self.confusion_matrix[0])
+    print("                    Predicted  ")
+    print("               --" + "-" * 5 * nSize)
+    sLabel = "Actual"
+    for nIndex, nRow in enumerate(self.confusion_matrix):
+      print("        %s | %s |" % (sLabel, " ".join(["%4d" % x for x in nRow])))
+      if nIndex == 0:
+        sLabel = " " * len(sLabel)
+    print("               --" + "-" * 5 * nSize)
+    print()
+  # --------------------------------------------------------------------------------------------------------------
+  def format_series_as_pc(self, metric_series):
+    oValStr = []
+    for x in metric_series:
+      sX = f"{x*100.0:.2f}"
+      oValStr.append(sX)
+
+    oValues = [f"{x:^7}" for x in oValStr]
+    return " |".join(oValues)
+  # --------------------------------------------------------------------------------------------------------------
+  def print_per_class(self, class_names=None):
+    if class_names is not None:
+      nClassCount = len(class_names.keys())
+      oClasses = [f"{class_names[x]:7}" for x in list(range(nClassCount))]
+    else:
+      oClasses = sorted(np.unique(self.actual_classes))
+      nClassCount = len(oClasses)
+      oClasses = [f"{x:^7}" for x in oClasses]
+    self.class_count = nClassCount
+
+    sClasses = " |".join(oClasses)
+    nRepeat = 28 + (7+2)*self.class_count
+    print(f"                            |{sClasses}|")
+    print("-"*nRepeat)
+    print(f"Per Class Recall %          |{self.format_series_as_pc(self.recall[:])}|")
+    print(f"Per Class Precision %       |{self.format_series_as_pc(self.precision[:])}|")
+    print("-" * nRepeat)
+  # --------------------------------------------------------------------------------------------------------------
+  def print_overall(self):
+    print(f"Weighted Average Recall %   :{self.average_recall*100.0:.3f}")
+    print(f"Weighted Average Precision %:{self.average_precision*100.0:.3f}")
+    print(f"Accuracy %                  :{self.accuracy*100.0       :.3f}")
+    print(f"Average F1 Score %          :{self.average_f1score*100.0:.3f}")
+    if (self.class_count == 2) and (self.auc is not None):
+      print(f"Area Under the Curve (AUC):{self.auc:.4f}")
+    print()
+  # --------------------------------------------------------------------------------------------------------------
+
+
+# ==============================================================================================================================
+
+
+# alias for compatibility
+class CEvaluator(EvaluateClassification):
+  pass
+

radnn-0.0.5/src/radnn/experiment/__init__.py

@@ -0,0 +1,4 @@
+from .ml_experiment_config import get_experiment_code, get_experiment_code_ex, experiment_number_and_variation, experiment_code_and_timestamp
+from .ml_experiment_config import MLExperimentConfig
+from .ml_experiment_env import MLExperimentEnv
+

{radnn-0.0.3 → radnn-0.0.5}/src/radnn/experiment/ml_experiment_config.py

@@ -25,31 +25,88 @@
 
 import os
 import json
+import re
+from datetime import datetime
 
+from radnn.system import FileSystem
 
 # --------------------------------------------------------------------------------------
-def experiment_code(config_dict):
+def legacy_model_code(config_dict):
+  if "ModelName" in config_dict:
+    sCode = config_dict["ModelName"]
+    if "ModelVariation" in config_dict:
+      sCode += "_" + config_dict["ModelVariation"]
+    if "ExperimentNumber" in config_dict:
+      sCode = sCode + "_%02d" % config_dict["ExperimentNumber"]
+  else:
+    raise Exception("Invalid experiment configuration. Needs at least the key 'ModelName'.")
+  return sCode
+# --------------------------------------------------------------------------------------
+def get_experiment_code(config_dict):
   if ("Experiment.BaseName" in config_dict) and ("Experiment.Number" in config_dict):
     sBaseName = config_dict["Experiment.BaseName"]
     nNumber = int(config_dict["Experiment.Number"])
     sVariation = None
     if "Experiment.Variation" in config_dict:
-      sVariation = config_dict["Experiment.Variation"]
+      sVariation = str(config_dict["Experiment.Variation"])
     nFoldNumber = None
     if "Experiment.FoldNumber" in config_dict:
-      nFoldNumber = config_dict["Experiment.FoldNumber"]
+      nFoldNumber = int(config_dict["Experiment.FoldNumber"])
 
-    sCode = "%s_%02d" % (sBaseName, nNumber)
+    sCode = f"{sBaseName}_{nNumber:02d}"
     if sVariation is not None:
-      sCode += ".%s" % str(sVariation)
+      sCode += "." + sVariation
     if nFoldNumber is not None:
-      sCode += "-%02d" % int(nFoldNumber)
+      sCode += f"-{nFoldNumber:02d}"
   else:
     raise Exception("Invalid experiment configuration. Needs at least two keys 'Experiment.BaseName'\n"
                   + "and `Experiment.Number`.")
 
   return sCode
 # --------------------------------------------------------------------------------------
+def get_experiment_code_ex(base_name, number, variation=None, fold_number=None):
+  if (base_name is not None) and (number is not None):
+    nNumber = int(number)
+    sVariation = None
+    if variation is not None:
+      sVariation = str(variation)
+    nFoldNumber = None
+    if fold_number is not None:
+      nFoldNumber = int(fold_number)
+
+    sCode = f"{base_name}_{nNumber:02d}"
+    if variation is not None:
+      sCode += "." + sVariation
+    if nFoldNumber is not None:
+      sCode += f"-{nFoldNumber:02d}"
+  else:
+    raise Exception("Invalid experiment code parts. Needs a base name and a number.")
+
+  return sCode
+# --------------------------------------------------------------------------------------
+def experiment_number_and_variation(experiment_code):
+  if type(experiment_code) == int:
+    nNumber = int(experiment_code)
+    sVariation = None
+  else:
+    sParts = experiment_code.split(".")
+    nNumber = int(sParts[0])
+    if len(sParts) > 1:
+      sVariation = sParts[1]
+    else:
+      sVariation = None
+
+  return nNumber, sVariation
+# --------------------------------------------------------------------------------------
+def experiment_code_and_timestamp(filename):
+  sName, _ = os.path.splitext(os.path.split(filename)[1])
+  sParts = re.split(r"_", sName, 2)
+  sISODate = f"{sParts[0]}T{sParts[1][0:2]}:{sParts[1][2:4]}:{sParts[1][4:6]}"
+  sExperimentCode = sParts[2]
+  dRunTimestamp = datetime.fromisoformat(sISODate)
+  return sExperimentCode, dRunTimestamp
+# --------------------------------------------------------------------------------------
+
 
 
 
@@ -58,27 +115,27 @@ def experiment_code(config_dict):
 # =========================================================================================================================
 class MLExperimentConfig(dict):
   # --------------------------------------------------------------------------------------
-  def __init__(self, filename=None, expt_base_name=None, expt_number=None, expt_variation=None, expt_fold=None, hyperparams=None):
-    self["Experiment.BaseName"] = expt_base_name
+  def __init__(self, filename=None, base_name=None, number=None, variation=None, fold_number=None, hyperparams=None):
+    self["Experiment.BaseName"] = base_name
     self.filename = filename
-    if filename is not None:
+    if self.filename is not None:
       self.load()
 
-    if expt_number is not None:
-      self["Experiment.Number"] = expt_number
-    if expt_variation is not None:
-      self["Experiment.Variation"] = expt_variation
-    if expt_fold is not None:
-      self["Experiment.FoldNumber"] = expt_fold
+    if number is not None:
+      self["Experiment.Number"] = number
+    if variation is not None:
+      self["Experiment.Variation"] = variation
+    if fold_number is not None:
+      self["Experiment.FoldNumber"] = fold_number
 
     if hyperparams is not None:
       self.assign(hyperparams)
   # --------------------------------------------------------------------------------------
   @property
   def experiment_code(self):
-    return experiment_code(self)
+    return get_experiment_code(self)
   # --------------------------------------------------------------------------------------
-  def load(self, filename, must_exist=False):
+  def load(self, filename=None, must_exist=False):
     if filename is None:
       filename = self.filename
 
@@ -118,16 +175,22 @@ class MLExperimentConfig(dict):
     return self
 
   # --------------------------------------------------------------------------------------
-  def save_config(self, filesystem, filename_only=None):
+  def save_config(self, fs, filename_only=None):
+    if isinstance(fs, FileSystem):
+      fs = fs.configs
+
     if filename_only is None:
-      filename_only = experiment_code(self)
+      filename_only = get_experiment_code(self)
 
-    sFileName = filesystem.configs.file(filename_only + ".json")
+    sFileName = fs.file(filename_only + ".json")
     return self.save(sFileName)
 
   # --------------------------------------------------------------------------------------
-  def load_config(self, filesystem, filename_only):
-    sFileName = filesystem.configs.file(filename_only + ".json")
+  def load_config(self, fs, filename_only):
+    if isinstance(fs, FileSystem):
+      fs = fs.configs
+
+    sFileName = fs.file(filename_only + ".json")
     return self.load(sFileName)
   # --------------------------------------------------------------------------------------
   def setDefaults(self):

radnn-0.0.5/src/radnn/experiment/ml_experiment_env.py

@@ -0,0 +1,223 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2023-2025 Pantelis I. Kaplanoglou
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# ......................................................................................
+
+import os
+import shutil
+import sys
+import re
+
+from radnn.experiment import MLExperimentConfig
+from radnn.experiment import get_experiment_code_ex, experiment_number_and_variation, experiment_code_and_timestamp
+from radnn.core import now_iso
+from radnn.system import FileSystem, FileStore
+from radnn.system.tee_logger import TeeLogger
+
+
+
+class MLExperimentEnv(dict):
+
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def experiment_filename_split(cls, filename):
+    sTryFileName, sTryExt = os.path.splitext(filename)
+    bIsVariationAndFold = "-" in sTryExt
+    if bIsVariationAndFold:
+      #LREXPLAINET22_MNIST_64.1-01
+      sMainParts = filename.split("-")
+      assert len(sMainParts) == 2, "Wrong experiment filename"
+      sFoldNumber, _ = os.path.splitext(sMainParts[1])
+      sParts = sMainParts[0].split("_")
+      sModelName = f"{sParts[0]}_{sParts[1]}"
+      sModelVar = sParts[2]
+    else:
+      sFileNameOnly, _ = os.path.splitext(filename)
+      sMainParts = sFileNameOnly.split("-")
+      if len(sMainParts) > 1:
+        sFoldNumber = sMainParts[1]
+      else:
+        sFoldNumber = None
+      sParts = sMainParts[0].split("_")
+      sModelName = f"{sParts[0]}_{sParts[1]}"
+      sModelVar = sParts[2]
+
+    return sModelName, sModelVar, sFoldNumber
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  @classmethod
+  def preload_config(cls, config_folder, experiment_group=None, experiment_base_name=None, experiment_variation=None, experiment_fold_number=None, experiment_filename=None):
+    oPrintOutput = []
+    oPrintOutput.append(f"[?] Experiment started at {now_iso()}")
+    oPrintOutput.append(f" |__ {'model':<24}: {experiment_base_name}")
+
+    dExperimentSpec = {"base_name": experiment_base_name, "variation": experiment_variation, "fold_number": experiment_fold_number}
+    if experiment_filename is not None:
+      # LREXPLAINET18_MNIST_08.1-01.json
+      _, sFileNameFull = os.path.split(experiment_filename)
+      experiment_base_name, experiment_variation, experiment_fold_number = cls.experiment_filename_split(sFileNameFull)
+      experiment_fold_number = int(experiment_fold_number)
+      dExperimentSpec = {"base_name": experiment_base_name, "variation": experiment_variation, "fold_number": experiment_fold_number}
+
+    if experiment_group is not None:
+      config_folder = os.path.join(config_folder, experiment_group)
+    oConfigFS = FileStore(config_folder, must_exist=True)
+
+    if "." in experiment_variation:
+      sParts = experiment_variation.split(".")
+      experiment_variation = f"{int(sParts[0]):02d}.{sParts[1]}"
+    else:
+      experiment_variation = f"{int(experiment_variation):02d}"
+    sMessage = f" |__ {'variation':<24}: {experiment_variation}"
+
+    if experiment_fold_number is not None:
+      experiment_variation = f"{experiment_variation}-{experiment_fold_number:02d}"
+      sMessage += f" fold: {experiment_fold_number}"
+    oPrintOutput.append(sMessage)
+
+    if experiment_filename is not None:
+      sExperimentFileName = experiment_filename
+    else:
+      sExperimentFileName = oConfigFS.file(f"{experiment_base_name}_{experiment_variation}.json")
+    oConfig = MLExperimentConfig(sExperimentFileName,p_nExperimentNumber=experiment_variation)
+    oPrintOutput.append(f" |__ {'configuration file':<24}: {sExperimentFileName}")
+
+    return oConfig, oPrintOutput, dExperimentSpec
+  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, config_fs, model_fs=None, base_name=None, number=None, variation=None, fold_number=None,
+               experiment_filename=None, experiment_code=None, experiment_config=None, model_filestore=None):
+
+    if isinstance(config_fs, FileSystem):
+      oConfigFS = config_fs.configs
+      oModelFS  = config_fs.models
+    else:
+      oConfigFS = config_fs
+      oModelFS = model_fs
+      if oModelFS is None:
+        oModelFS = config_fs
+
+    # ...................... | Fields | ......................
+    self.config_fs = oConfigFS
+    self.model_fs  = oModelFS
+    self.base_name = base_name
+    self.number = number
+    self.variation  = variation
+    self.fold_number = fold_number
+
+    if (experiment_filename is not None) or (experiment_code is not None):
+      self.base_name, self.number, self.variation, self.fold_number, _ = self.determine_code_parts(experiment_filename,
+                                                                      experiment_code, number, variation, fold_number)
+
+    self.experiment_filename = experiment_filename
+    if self.experiment_filename is None:
+      sExperimentCode = get_experiment_code_ex(self.base_name, self.number, self.variation, self.fold_number)
+      if experiment_code is not None:
+        assert sExperimentCode == experiment_code, "Re-created experiment code mismatch."
+      self.experiment_filename = self.config_fs.file(f"{sExperimentCode}.json")
+
+
+    self.is_debugable = False
+    self.is_retraining = False
+
+    self._config = experiment_config
+    if self._config is None:
+      self._config = MLExperimentConfig(self.experiment_filename, number=self.number)
+    self.experiment_fs = self.model_fs.subfs(self.experiment_code)
+    # ........................................................
+
+  # --------------------------------------------------------------------------------------------------------------------
+  def save_config(self):
+    self._config.save(self.experiment_filename)
+  # --------------------------------------------------------------------------------------------------------------------
+  def determine_code_parts(self, experiment_filename, experiment_code, number, variation, fold_number):
+    sExperimentCode = None
+    if experiment_code is not None:
+      sExperimentCode = experiment_code
+    elif experiment_filename is not None:
+      _, sFileNameFull = os.path.split(experiment_filename)
+      sExperimentCode, _ = os.path.splitext(sFileNameFull)
+
+    sISODate = None
+    if sExperimentCode is not None:
+      oMatch = re.match(r"^\d{4}-\d{2}-\d{2}_\d{6}_", sExperimentCode)
+      if oMatch is not None:
+        sISODate = oMatch.group()[:-1]
+        sExperimentCode = sExperimentCode[18:]
+
+      base_name, variation, sFoldNumber = MLExperimentEnv.experiment_filename_split(sExperimentCode)
+      if sFoldNumber is not None:
+        fold_number = int(sFoldNumber)
+
+    if number is None:
+      number, variation = experiment_number_and_variation(variation)
+
+    return base_name, number, variation, fold_number, sISODate
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def config(self):
+    return self._config
+  # --------------------------------------------------------------------------------------------------------------------
+  @property
+  def experiment_code(self):
+    return get_experiment_code_ex(self.base_name, self.number, self.variation, self.fold_number)
+  # --------------------------------------------------------------------------------------------------------------------
+  def copy_config(self, start_timestamp):
+    sOriginalFileName = self.experiment_filename
+    sNewFileName = self.experiment_fs.file(f"{start_timestamp}_{self.experiment_code}.json")
+    shutil.copy(sOriginalFileName, sNewFileName)
+  # --------------------------------------------------------------------------------------------------------------------
+  def move_log(self, start_timestamp, original_filename):
+    self.copy_config(start_timestamp)
+    _, original_filename_only = os.path.split(original_filename)
+    sNewFileName = f"{start_timestamp}_{self.experiment_code}.{original_filename_only}"
+    shutil.move(original_filename, self.experiment_fs.file(sNewFileName))
+    sys.stdout = TeeLogger(self.experiment_fs.file(sNewFileName))
+  # --------------------------------------------------------------------------------------------------------------------
+  '''
+  def AssignSystemParams(self, p_oParamsDict):
+    self.number = p_oParamsDict["ModelNumber"]
+    self.is_debugable = p_oParamsDict["IsDebuggable"]
+    self.is_retraining = p_oParamsDict["IsRetraining"]
+
+    self._config = MLExperimentConfig(self.model_fs.file(self.experiment_code + ".json"), number=self.number)
+  '''
+  # --------------------------------------------------------------------------------------------------------------------
+  def __str__(self)->str:
+    sResult  = f"Experiment Code: {self.experiment_code} | Debugable: {self.is_debugable} | Retraining: {self.is_retraining}\n"
+    sResult += f" |___ base name: {self.base_name} , number:{self.number} , variation:{self.variation}, fold_number: {self.fold_number}\n"
+    sResult += f" |___ file name: {self.experiment_filename}\n"
+    sResult += f"Models FileStore    : {self.model_fs}\n"
+    sResult += f"Configs FileStore   : {self.config_fs}\n"
+    sResult += f"Experiment FileStore: {self.experiment_fs}\n"
+    sResult += f"Experiment Filename : {self.experiment_filename}\n"
+    sResult += f"Configuration\n"
+    sResult += "-"*40 + "\n"
+    sResult += str(self._config) + "\n"
+    return sResult
+  # --------------------------------------------------------------------------------------------------------------------
+  def __repr__(self)->str:
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------------------
+
+

radnn-0.0.5/src/radnn/plots/__init__.py

@@ -0,0 +1,4 @@
+from .plot_confusion_matrix import PlotConfusionMatrix
+from .plot_learning_curve import PlotLearningCurve
+from .plot_roc import PlotROC
+from .plot_voronoi_2d import PlotVoronoi2D

radnn-0.0.5/src/radnn/plots/plot_confusion_matrix.py

@@ -0,0 +1,54 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2020-2025 Pantelis I. Kaplanoglou
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# ......................................................................................
+
+
+import matplotlib.pyplot as plt
+
+class PlotConfusionMatrix(object):
+  # --------------------------------------------------------------------------------------
+  def __init__(self, confusion_matrix, title="Confusion Matrix"):
+    self.confusion_matrix = confusion_matrix
+    self.title = title
+  # --------------------------------------------------------------------------------------
+  def prepare(self):
+    fig, ax = plt.subplots(figsize=(7.5, 7.5))
+    ax.matshow(self.confusion_matrix, cmap=plt.cm.Blues, alpha=0.3)
+    for i in range(self.confusion_matrix.shape[0]):
+      for j in range(self.confusion_matrix.shape[1]):
+        ax.text(x=j, y=i, s=self.confusion_matrix[i, j], va='center', ha='center', size='xx-large')
+
+    plt.xlabel('Predicted Label', fontsize=18)
+    plt.ylabel('Actual Label', fontsize=18)
+    plt.title(self.title, fontsize=18)
+    return self
+  # --------------------------------------------------------------------------------------
+  def save(self, filename):
+    plt.savefig(filename, bbox_inches='tight')
+    return self
+  # --------------------------------------------------------------------------------------
+  def show(self):
+    plt.show()
+  # --------------------------------------------------------------------------------------
+