radnn 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

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

@@ -16,19 +16,7 @@ def is_opencv_installed():
 
 # ----------------------------------------------------------------------------------------------------------------------
 def system_name() -> str:
-  sPlatform = platform.system()
-  sHostName = socket.gethostname()
-  #sIPAddress = socket.gethostbyname(sHostName)
-
-  bIsColab = "google.colab" in sys.modules
-  if bIsColab:
-    sResult = "(colab)" #+ sIPAddress
-  else:
-    if sPlatform == "Windows":
-      sResult = "(windows)-" + sHostName
-    else:
-      sResult = "(linux)-" + sHostName
-  return sResult
+  return MLInfrastructure.host_name(False)
 # ----------------------------------------------------------------------------------------------------------------------
 def now_iso():
   return datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
@@ -42,4 +30,45 @@ def shell_command_output(command_string):
       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/evaluation/__init__.py

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

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/experiment/__init__.py

@@ -1,3 +1,4 @@
-from .ml_experiment_config import experiment_code, MLExperimentConfig
-
+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/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/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/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/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()
+  # --------------------------------------------------------------------------------------
+

radnn/plots/plot_learning_curve.py

@@ -0,0 +1,73 @@
+# ......................................................................................
+# 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 PlotLearningCurve(object):
+  # --------------------------------------------------------------------------------------
+  def __init__(self, metrics_dict, model_name):
+    self.metrics_dict = metrics_dict
+    self.model_name = model_name
+    print("Keys in training process log:", self.metrics_dict.keys())
+  # --------------------------------------------------------------------------------------
+  def prepare(self, metric_key="accuracy", custom_title=None, is_legend_right=False):
+    plt.clf()
+    plt.plot(self.metrics_dict[metric_key])
+    sValidationMetricName = "val_" + metric_key
+    if sValidationMetricName in self.metrics_dict:
+      plt.plot(self.metrics_dict[sValidationMetricName])
+    if custom_title is None:
+      plt.title(self.model_name + ' ' + metric_key)
+    else:
+      plt.title(self.model_name + ' ' + custom_title)
+    plt.ylabel(metric_key)
+    plt.xlabel("Epoch")
+    if is_legend_right:
+      plt.legend(["train", 'validation'], loc="upper right")
+    else:
+      plt.legend(["train", "validation"], loc="upper left")
+    return self
+  # --------------------------------------------------------------------------------------
+  def prepare_cost(self, cost_function=None):
+    if isinstance(cost_function, str):
+      sCostFunctionName = cost_function
+    else:
+      sClassName = str(cost_function.__class__)
+      if ("keras" in sClassName) and ("losses" in sClassName):
+        sCostFunctionNameParts = cost_function.name.split("_")
+        sCostFunctionNameParts = [x.capitalize() + " " for x in sCostFunctionNameParts]
+        sCostFunctionName = " ".join(sCostFunctionNameParts)
+
+    return self.prepare("loss", sCostFunctionName, True)
+  # --------------------------------------------------------------------------------------
+  def save(self, filename):
+    plt.savefig(filename, bbox_inches='tight')
+    return self
+  # --------------------------------------------------------------------------------------
+  def show(self):
+    plt.show()
+  # --------------------------------------------------------------------------------------
+
+

radnn/plots/plot_roc.py

@@ -0,0 +1,75 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2024-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.
+
+# ......................................................................................
+
+from sklearn import metrics
+import matplotlib.pyplot as plt
+
+'''
+    Receiver Operator Characteristics (ROC) Plot
+'''
+class PlotROC(object):
+  # --------------------------------------------------------------------------------------
+  def __init__(self, actual_labels, predicted_probs, title="Receiving Operator Characteristics Curve"):
+    self.actual_labels = actual_labels
+    self.predicted_probs = predicted_probs
+    self.title = title
+  # --------------------------------------------------------------------------------------
+  def prepare(self, true_threshold=0.5, figure_size=[6.00, 6.00], is_showing_grid=True):
+    plt.rcParams["figure.figsize"] = figure_size
+    plt.rcParams["figure.autolayout"] = True
+
+    nFPR, nTPR, nThresholds = metrics.roc_curve(self.actual_labels, self.predicted_probs)
+    nAUC = metrics.roc_auc_score(self.actual_labels, self.predicted_probs)
+    plt.xlim(0, 1.02)
+    plt.ylim(0, 1.02)
+    if is_showing_grid:
+      plt.grid()
+    plt.plot(nFPR, nTPR, label="ROC curve (AUC=%.2f)" % nAUC, linewidth=2)
+    plt.plot([0.0, 1.0], [0.0, 1.0], 'r--', label="Random prediction")  # , color="yellow", linewidth=1)
+
+    plt.ylabel("TPR (True Positive Rate)")
+    plt.xlabel("FPR (False Positive Rate)")
+
+    nPointIndex = None
+    for nThresholdIndex, nThreshold in enumerate(nThresholds):
+      if nThreshold < true_threshold:
+        nPointIndex = nThresholdIndex
+        break
+
+    if nPointIndex is not None:
+      plt.plot(nFPR[nPointIndex], nTPR[nPointIndex]
+              , label="Threshold %.2f" % nThreshold
+              , marker="o", markersize=10, markeredgecolor="blue", markerfacecolor="yellow")
+      plt.title(self.title, fontsize=18)
+      plt.legend(loc=4)
+    return self
+  # --------------------------------------------------------------------------------------
+  def save(self, filename):
+    plt.savefig(filename, bbox_inches='tight')
+    return self
+  # --------------------------------------------------------------------------------------
+  def show(self):
+    plt.show()
+  # --------------------------------------------------------------------------------------

radnn/plots/plot_voronoi_2d.py

@@ -0,0 +1,95 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2024-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
+import numpy as np
+from matplotlib import cm
+
+class PlotVoronoi2D(object):
+  # --------------------------------------------------------------------------------------
+  # Constructor
+  def __init__(self, samples_2d, labels, ground_truth_cluster_count=10, title="2D Voronoi Plot"):
+    # ................................................................
+    # // Fields \\
+    self.title                    = title
+    self.samples_2d               = samples_2d
+    self.labels                   = labels
+    self.ground_truth_cluster_count  = ground_truth_cluster_count
+
+    if (self.ground_truth_cluster_count <= 10):
+      self.color_map   = cm.get_cmap("tab10")
+    elif (self.ground_truth_cluster_count <= 20):
+      self.color_map   = cm.get_cmap("tab20")
+    else:
+      self.color_map = cm.get_cmap("prism")
+
+    self.point_size = 8
+    self.plot_dimensions = [14, 8]
+    # ................................................................
+  # --------------------------------------------------------------------------------------
+  def prepare_for_kmeans(self, kmeans_model):
+    reduced_data = self.samples_2d
+
+    # Step size of the mesh. Decrease to increase the quality of the VQ.
+    #h = .02     # point in the mesh [x_min, x_max]x[y_min, y_max].
+    h = .4     # point in the mesh [x_min, x_max]x[y_min, y_max].
+
+    # Plot the decision boundary. For that, we will assign a color to each
+    x_min, x_max = reduced_data[:, 0].min() - 1, reduced_data[:, 0].max() + 1
+    y_min, y_max = reduced_data[:, 1].min() - 1, reduced_data[:, 1].max() + 1
+    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
+
+    # Obtain labels for each point in mesh. Use last trained model.
+    Z = kmeans_model.predict(np.c_[xx.ravel(), yy.ravel()])
+
+    # Put the result into a color plot
+    Z = Z.reshape(xx.shape)
+    plt.figure(1, figsize=self.plot_dimensions)
+    plt.clf()
+    plt.imshow(Z, interpolation="nearest",
+               extent=(xx.min(), xx.max(), yy.min(), yy.max()),
+               cmap=cm.get_cmap("tab20"), aspect="auto", origin="lower")
+
+    #plt.plot(reduced_data[:, 0], reduced_data[:, 1], 'k.', markersize=2)
+    plt.scatter(reduced_data[:, 0], reduced_data[:, 1], c=self.labels, s=self.point_size, cmap=self.color_map)
+
+    # Plot the centroids as a white X
+    centroids = kmeans_model.cluster_centers_
+    plt.scatter(centroids[:, 0], centroids[:, 1], marker="x", s=169, linewidths=3
+                ,color="w", zorder=10 )
+    plt.title(self.title)
+    plt.xlim(x_min, x_max)
+    plt.ylim(y_min, y_max)
+    plt.xticks(())
+    plt.yticks(())
+  # --------------------------------------------------------------------------------------
+  def save(self, filename):
+    plt.savefig(filename, bbox_inches='tight')
+    return self
+  # --------------------------------------------------------------------------------------
+  def show(self):
+    plt.show()
+  # --------------------------------------------------------------------------------------

radnn/system/__init__.py

@@ -1,5 +1,6 @@
 from .filestore import FileStore
 from .filesystem import FileSystem
+from .tee_logger import TeeLogger
 
 
 

radnn/system/filesystem.py

@@ -33,55 +33,77 @@ from radnn.system.files import JSONFile
 # =======================================================================================================================
 class FileSystem(object):
   # --------------------------------------------------------------------------------------------------------
-  def __init__(self, config_folder=None, model_folder=None, dataset_folder=None, model_group=None, must_exist=False, setup_filename=None):
+  def __init__(self, config_folder="MLConfig", model_folder="MLModels", dataset_folder="MLData", must_exist=False, setup_filename="*auto*"):
     '''
     Initializes the file system settings for an experiment
     :param config_folder: The folder that contains the experiment hyperparameter files.
     :param model_folder: The main folder where the models are stored.
     :param dataset_folder: The main folder under which dataset folder are stores.
-    :param model_group: A group of models under the main folder will be used instead.
     :param setup_filename: The filename of the setup file.
     :param must_exist: False: Auto-creates the directories on the file system | True: Raises an error if it does not exist.
     '''
 
     self.setup_filename = setup_filename
-    if self.setup_filename is None:
+    if self.setup_filename == "*auto*":
       self.setup_filename = system_name() + ".fsys"
+    self._must_exist = must_exist
+    self._has_loaded_groups = False
+    self.model_groups = []
 
-    if os.path.exists(self.setup_filename):
-      oFile = JSONFile(self.setup_filename)
-      dSetup = oFile.load()
-      config_folder = dSetup["Configs"]
-      model_folder = dSetup["Models"]
-      dataset_folder = dSetup["Datasets"]
-      if model_group is None:
-        if "ModelGroup" in dSetup:
-          model_group = dSetup["ModelGroup"]
-    else:
+    dSetup = None
+    if self.setup_filename is not None:
+      if os.path.exists(self.setup_filename):
+        oFile = JSONFile(self.setup_filename)
+        dSetup = oFile.load()
+        config_folder = dSetup["Configs"]
+        model_folder = dSetup["Models"]
+        dataset_folder = dSetup["Datasets"]
+        if "ModelGroups" in dSetup:
+          self.model_groups = dSetup["ModelGroups"]
+          self._has_loaded_groups = True
+
+    if dSetup is None:
       dSetup = dict()
       dSetup["Configs"] = config_folder
       dSetup["Models"] = model_folder
       dSetup["Datasets"] = dataset_folder
 
-    if model_group is not None:
-      config_folder   = os.path.join(config_folder, model_group)
-      model_folder    = os.path.join(model_folder, model_group)
+
+    if len(self.model_groups) > 0:
+      for model_group in self.model_groups:
+        config_folder   = os.path.join(config_folder, model_group)
+        model_folder    = os.path.join(model_folder, model_group)
 
     # ...................... | Fields | ......................
     self.setup = dSetup
-    self.configs   = FileStore(config_folder, must_exist=must_exist)
-    self.models    = FileStore(model_folder, must_exist=must_exist)
-    self.datasets  = FileStore(dataset_folder, must_exist=must_exist)
+    self.configs   = FileStore(config_folder, must_exist=self._must_exist)
+    self.models    = FileStore(model_folder, must_exist=self._must_exist)
+    self.datasets  = FileStore(dataset_folder, must_exist=self._must_exist)
     # ........................................................
   # --------------------------------------------------------------------------------------------------------
+  def group(self, group_name):
+    if not self._has_loaded_groups:
+      if group_name is not None:
+          self.model_groups.append(group_name)
+          self.setup["ModelGroups"] = self.model_groups
+
+          self.configs   = self.configs.subfs(group_name, must_exist=self._must_exist)
+          self.models    = self.models.subfs(group_name, must_exist=self._must_exist)
+
+    return self
+  # --------------------------------------------------------------------------------------------------------
   def save_setup(self):
     oFile = JSONFile(self.setup_filename)
     oFile.save(self.setup)
   # --------------------------------------------------------------------------------------------------------
   def __str__(self)->str:
-    sResult = f"  ConfigsFolder: \"{self.configs.base_folder}\",\n"
-    sResult += f"  ModelsFolder: \"{self.models.base_folder}\",\n"
-    sResult += f"  DatasetsFolder: \"{self.datasets.base_folder}\"\n"
+    sResult = f"  Configs: \"{self.configs.base_folder}\",\n"
+    sResult += f"  Models: \"{self.models.base_folder}\",\n"
+    sResult += f"  Datasets: \"{self.datasets.base_folder}\"\n"
+    if len(self.model_groups) > 0:
+      sModelGroups = str(self.model_groups)
+      sModelGroups = sModelGroups.replace("'", "\"")
+      sResult += f"  ModelGroups: {sModelGroups}\n"
     sResult = "{\n" + sResult + "}"
     return sResult
   # --------------------------------------------------------------------------------------------------------

radnn/system/hosts/__init__.py

@@ -0,0 +1,10 @@
+from radnn.core import MLInfrastructure
+
+if MLInfrastructure.is_windows():
+  from .windows_host import WindowsHost
+
+if MLInfrastructure.is_colab():
+  from .colab_host import ColabHost
+
+if MLInfrastructure.is_linux():
+  from .linux_host import LinuxHost

radnn/system/hosts/colab_host.py

@@ -0,0 +1,52 @@
+import os
+from google.colab import drive
+from google.colab import files
+from radnn.core import MLInfrastructure
+
+COLAB_ROOT_FOLDER = "/content/gdrive/My Drive/Colab Notebooks"
+
+class ColabHost(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  def __init__(self, colab_root=COLAB_ROOT_FOLDER, workspace_folder=None):
+    self.colab_root = colab_root
+    self.workspace_prefixes = None
+    self.workspace_folder = workspace_folder
+    self.current_folder = None
+
+    drive.mount("/content/gdrive")
+  # --------------------------------------------------------------------------------------------------------------------
+  def detect_workspace(self, prefixes=None):
+    self.workspace_prefixes = prefixes
+
+    if self.workspace_prefixes is None:
+      self.workspace_folder = self.colab_root
+    else:
+      self.workspace_folder = None
+      for sProjectsFolder in os.listdir(self.colab_root):
+        for sPrefix in self.workspace_prefixes:
+          if sProjectsFolder.startswith(sPrefix):
+            self.workspace_folder = os.path.join(self.colab_root, sProjectsFolder)
+            break
+    return self
+  # --------------------------------------------------------------------------------------------------------------------
+  def change_dir(self, path):
+    self.current_folder = path
+    os.chdir(self.current_folder)
+    print("Current directory is: ", os.getcwd())
+  # --------------------------------------------------------------------------------------------------------------------
+  def change_to_project_dir(self, project_name):
+    if self.workspace_folder is not None:
+      self.current_folder = os.path.join(self.workspace_folder, project_name)
+    else:
+      self.current_folder = os.path.join(self.colab_root, project_name)
+    os.chdir(self.current_folder)
+    print("Current directory is: ", os.getcwd())
+
+    return self
+  # --------------------------------------------------------------------------------------------------------
+  def __str__(self)->str:
+    return f"Host: {MLInfrastructure.host_name()}"
+  # --------------------------------------------------------------------------------------------------------
+  def __repr__(self)->str:
+    return self.__str__()
+  # --------------------------------------------------------------------------------------------------------

radnn/system/hosts/linux_host.py

@@ -0,0 +1,3 @@
+class LinuxHost(object):
+  def __init__(self):
+    pass

radnn/system/hosts/windows_host.py

@@ -0,0 +1,41 @@
+import win32api
+
+class WindowsHost(object):
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def dll_info_root(self, dll_filename):
+    dInfo = dict()
+    ver_strings = ('Comments', 'InternalName', 'ProductName',
+                   'CompanyName', 'LegalCopyright', 'ProductVersion',
+                   'FileDescription', 'LegalTrademarks', 'PrivateBuild',
+                   'FileVersion', 'OriginalFilename', 'SpecialBuild')
+    # fname = os.environ["comspec"]
+    dFileVersionInfo = win32api.GetFileVersionInfo(dll_filename, '\\')
+    ## backslash as parm returns dictionary of numeric info corresponding to VS_FIXEDFILEINFO struc
+
+    for sKey, oValue in dFileVersionInfo.items():
+      dInfo[sKey] = oValue
+    return dInfo
+  # --------------------------------------------------------------------------------------------------------------------
+  @classmethod
+  def dll_info(cls, dll_filename):
+    dInfo = dict()
+
+    dFileVersionsInfo = win32api.GetFileVersionInfo(dll_filename, '\\VarFileInfo\\Translation')
+    ## \VarFileInfo\Translation returns list of available (language, codepage) pairs that can be used to retreive string info
+    ## any other must be of the form \StringfileInfo\%04X%04X\parm_name, middle two are language/codepage pair returned from above
+    dInfo = dict()
+    for sLanguageCode, sCodePage in dFileVersionsInfo:
+      dInfo["lang"] = sLanguageCode
+      dInfo["codepage"] = sCodePage
+
+      #print('lang: ', lang, 'codepage:', codepage)
+      oVersionStrings = ('Comments', 'InternalName', 'ProductName',
+                     'CompanyName', 'LegalCopyright', 'ProductVersion',
+                     'FileDescription', 'LegalTrademarks', 'PrivateBuild',
+                     'FileVersion', 'OriginalFilename', 'SpecialBuild')
+      for sVersionString in oVersionStrings:
+        str_info = u'\\StringFileInfo\\%04X%04X\\%s' % (sLanguageCode, sCodePage, sVersionString)
+        dInfo[sVersionString] = repr(win32api.GetFileVersionInfo(dll_filename, str_info))
+    return dInfo
+  # --------------------------------------------------------------------------------------------------------------------

radnn/system/tee_logger.py

@@ -0,0 +1,60 @@
+# ......................................................................................
+# MIT License
+
+# Copyright (c) 2024-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 sys
+from datetime import datetime
+
+
+class TeeLogger(object):
+  # --------------------------------------------------------------------------------------------------------
+  def __init__(self, file_name):
+    self.last_flush = datetime.now()
+    sMode = "w"
+    if os.path.exists(file_name):
+      sMode = "a"
+    self.file = open(file_name, sMode)
+    self.stdout = sys.stdout
+    self.isclosed = False
+# --------------------------------------------------------------------------------------------------------
+  def write(self, message):
+    self.stdout.write(message)
+    self.file.write(message)
+    dNow = datetime.now()
+    oDelta = dNow - self.last_flush
+    if oDelta.total_seconds() >= 5:
+      self.flush()
+      self.last_flush = dNow
+  # --------------------------------------------------------------------------------------------------------
+  def flush(self):
+    if not self.isclosed:
+      self.stdout.flush()
+      self.file.flush()
+  # --------------------------------------------------------------------------------------------------------
+  def close(self):
+    self.isclosed = True
+    self.stdout.close()
+    self.file.close()
+  # --------------------------------------------------------------------------------------------------------

{radnn-0.0.3.dist-info → radnn-0.0.5.dist-info}/METADATA

@@ -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.5.dist-info/RECORD

@@ -0,0 +1,32 @@
+radnn/__init__.py,sha256=FqalNi2naG2HW4WceCD7_Tnp8cHHUXCCY9HYsg9Buxk,140
+radnn/core.py,sha256=cWGl_B3bHASEDdZHgDKN9CwGo7-TFjj3y2YD-Ei4bD4,2828
+radnn/evaluation/__init__.py,sha256=7dXDyJfOpSAr7G8jfDofsW4YEHNElCTTyMXuLCtpoOI,59
+radnn/evaluation/evaluate_classification.py,sha256=wacQ_02loI2ApOKrUIDTKqqrwi0_TpUZJQfTpJ6rtag,5497
+radnn/experiment/__init__.py,sha256=8gxrFS4bG7rg2kgrDEhemJgDbO-5KhBYc4owJZ-S--k,247
+radnn/experiment/ml_experiment_config.py,sha256=MuFb4sY4kgCwxtJGmpOace4eTopy7mVLg3IDCpy6evI,8547
+radnn/experiment/ml_experiment_env.py,sha256=I54WILYjCJf9P133dFgOMsXGxkftlU8DcmwXDnBW930,11151
+radnn/plots/__init__.py,sha256=sfhHqTDmYce5tg8jLJCN1IkELwbW3TCibm0PEYoomKY,181
+radnn/plots/plot_confusion_matrix.py,sha256=KWW5k7-gaLPXO4oQBnzwAwgI-rvPOmqw8uiZbFlmU5o,2625
+radnn/plots/plot_learning_curve.py,sha256=tgx3vAm4rg5qScqxLQ2T82BqrRWjiYaIKgLQp5Y19cQ,3480
+radnn/plots/plot_roc.py,sha256=iyOnhux2qFEs7W-szEOCg2VCkcnBEaOJxZkWWYuSnCQ,3493
+radnn/plots/plot_voronoi_2d.py,sha256=Kq3ZaLhLaFHQAurhFKNy7NNuIm3RArCk_WxPT8Ftxek,4409
+radnn/system/__init__.py,sha256=uJLg56njcLtaRO0Kyudat055DGxqWsLMvrn9P8_Rt6A,119
+radnn/system/filestore.py,sha256=gNESaiJNwdrFbkzcbkSv-O4V8vrBagOSR90WcFueNsA,8977
+radnn/system/filesystem.py,sha256=jt37OP9UgdJihjKLRWpMmERt1L0EdS-uPRrdIduH_BQ,5523
+radnn/system/tee_logger.py,sha256=WcyIJiW851PP6Jk7SyCHj63BEt7HnWa5-GJtw1CjGHE,2629
+radnn/system/files/__init__.py,sha256=u2oGHNKM362JwqrDgwmWTAiisL067h6H9uu-d0iTBks,169
+radnn/system/files/csvfile.py,sha256=9uKqmCdqLAKomANejcSruHle1r3gVdByQb1I2otLcMs,2246
+radnn/system/files/fileobject.py,sha256=qT9qzpH6YFSIzaKfILxhpaQ1P2o2tqRh9J5J2L_Kp8Y,3851
+radnn/system/files/imgfile.py,sha256=HxvvittOUG1mmIp-Bg8vHnLPtRYD-N4nE86G0Rcys6M,2242
+radnn/system/files/jsonfile.py,sha256=CX0Y6kPEaF_eEUb8ah-5Wvp35JRVYcpvOXg-DCxRnf0,3172
+radnn/system/files/picklefile.py,sha256=0BFiYzr6BbGWMXyQCMjYHa_GlW8nEZ95CQtn7lpH254,5526
+radnn/system/files/textfile.py,sha256=r7FZ1pdFGYxKrQ_kgkEK35GIqRU8k_MjdB0OrDd5m0o,2891
+radnn/system/hosts/__init__.py,sha256=k2gkMJhe96Nf-V2ex6jZqmCRX9vA_K6gFB8J8Ii9ahc,261
+radnn/system/hosts/colab_host.py,sha256=tAuLn9gTkX9cCSEmm7sG1JmCtNIgFlASwBt2olHUSe4,2434
+radnn/system/hosts/linux_host.py,sha256=TZ-5JEZV0WNEB5trTbRWM0REhpuK5oYxoLodKKqhm9s,57
+radnn/system/hosts/windows_host.py,sha256=u4IvgfFoKWdrFy0hYG__AoxfEJYHF4-ISNXTCJ5uN8I,2257
+radnn-0.0.5.dist-info/LICENSE.txt,sha256=vYtt_GDvm_yW65X9YMBOOu8Vqc9SAvqH94TbfBc2ckU,1106
+radnn-0.0.5.dist-info/METADATA,sha256=_9T1n2CkCwcPhzFOtQcP4E8s6GkzQI4Q2TLEU2aeNF4,2861
+radnn-0.0.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+radnn-0.0.5.dist-info/top_level.txt,sha256=FKlLIm6gRAeZlRzs-HCBJAB1q9ELJ7MgaL-qqFuPo6M,6
+radnn-0.0.5.dist-info/RECORD,,

radnn-0.0.3.dist-info/RECORD

@@ -1,19 +0,0 @@
-radnn/__init__.py,sha256=arFgYRlsbwGiNdsYNwxWkafpqvG4x9-7Xw4gwehj6Ds,109
-radnn/core.py,sha256=1CNl5Qejop4pCUIDfHEx97PO3bQVq1WrQ-a5IIRGaCE,1665
-radnn/experiment/__init__.py,sha256=GqESBzSW5fyoFENFOWLC4FB0xqqn0KleEiWRPZG6_Dc,75
-radnn/experiment/ml_experiment_config.py,sha256=6REP6lT4Rj6_WXu3kuPsOSX4DkCAC8ZpR-2Ua2fQffU,6280
-radnn/system/__init__.py,sha256=kFFqJ3SPucLmSoL4QP2TBO7IdFfjmgn3eGh6HGMFOM0,84
-radnn/system/filestore.py,sha256=gNESaiJNwdrFbkzcbkSv-O4V8vrBagOSR90WcFueNsA,8977
-radnn/system/filesystem.py,sha256=16m3-WDXGs5HoasbV7s7--bFSdfs9zYTg6nwTvqy22s,4642
-radnn/system/files/__init__.py,sha256=u2oGHNKM362JwqrDgwmWTAiisL067h6H9uu-d0iTBks,169
-radnn/system/files/csvfile.py,sha256=9uKqmCdqLAKomANejcSruHle1r3gVdByQb1I2otLcMs,2246
-radnn/system/files/fileobject.py,sha256=qT9qzpH6YFSIzaKfILxhpaQ1P2o2tqRh9J5J2L_Kp8Y,3851
-radnn/system/files/imgfile.py,sha256=HxvvittOUG1mmIp-Bg8vHnLPtRYD-N4nE86G0Rcys6M,2242
-radnn/system/files/jsonfile.py,sha256=CX0Y6kPEaF_eEUb8ah-5Wvp35JRVYcpvOXg-DCxRnf0,3172
-radnn/system/files/picklefile.py,sha256=0BFiYzr6BbGWMXyQCMjYHa_GlW8nEZ95CQtn7lpH254,5526
-radnn/system/files/textfile.py,sha256=r7FZ1pdFGYxKrQ_kgkEK35GIqRU8k_MjdB0OrDd5m0o,2891
-radnn-0.0.3.dist-info/LICENSE.txt,sha256=vYtt_GDvm_yW65X9YMBOOu8Vqc9SAvqH94TbfBc2ckU,1106
-radnn-0.0.3.dist-info/METADATA,sha256=fYW8JdhjMVYxbnseMrLVO_TEP7rqc50zrXLhd--jM1M,2861
-radnn-0.0.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-radnn-0.0.3.dist-info/top_level.txt,sha256=FKlLIm6gRAeZlRzs-HCBJAB1q9ELJ7MgaL-qqFuPo6M,6
-radnn-0.0.3.dist-info/RECORD,,